/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.1
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */


#ifndef SWIGPYTHON
#define SWIGPYTHON
#endif

#define SWIG_PYTHON_DIRECTOR_NO_VTABLE

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


#if defined(__GNUC__) && defined(_WIN32) && !defined(SWIG_PYTHON_NO_HYPOT_WORKAROUND)
/* Workaround for '::hypot' has not been declared', see https://bugs.python.org/issue11566 */
# include <math.h>
#endif

#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
/* Use debug wrappers with the Python release dll */
# undef _DEBUG
# include <Python.h>
# define _DEBUG 1
#else
# include <Python.h>
#endif

/* -----------------------------------------------------------------------------
 * swigrun.swg
 *
 * This file contains generic C API SWIG runtime support for pointer
 * type checking.
 * ----------------------------------------------------------------------------- */

/* This should only be incremented when either the layout of swig_type_info changes,
   or for whatever reason, the runtime changes incompatibly */
#define SWIG_RUNTIME_VERSION "4"

/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
#ifdef SWIG_TYPE_TABLE
# define SWIG_QUOTE_STRING(x) #x
# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
#else
# define SWIG_TYPE_TABLE_NAME
#endif

/*
  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
  creating a static or dynamic library from the SWIG runtime code.
  In 99.9% of the cases, SWIG just needs to declare them as 'static'.

  But only do this if strictly necessary, ie, if you have problems
  with your compiler or suchlike.
*/

#ifndef SWIGRUNTIME
# define SWIGRUNTIME SWIGINTERN
#endif

#ifndef SWIGRUNTIMEINLINE
# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
#endif

/*  Generic buffer size */
#ifndef SWIG_BUFFER_SIZE
# define SWIG_BUFFER_SIZE 1024
#endif

/* Flags for pointer conversions */
#define SWIG_POINTER_DISOWN        0x1
#define SWIG_CAST_NEW_MEMORY       0x2
#define SWIG_POINTER_NO_NULL       0x4

/* Flags for new pointer objects */
#define SWIG_POINTER_OWN           0x1


/*
   Flags/methods for returning states.

   The SWIG conversion methods, as ConvertPtr, return an integer
   that tells if the conversion was successful or not. And if not,
   an error code can be returned (see swigerrors.swg for the codes).

   Use the following macros/flags to set or process the returning
   states.

   In old versions of SWIG, code such as the following was usually written:

     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
       // success code
     } else {
       //fail code
     }

   Now you can be more explicit:

    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
    } else {
      // fail code
    }

   which is the same really, but now you can also do

    Type *ptr;
    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
    if (SWIG_IsOK(res)) {
      // success code
      if (SWIG_IsNewObj(res) {
        ...
	delete *ptr;
      } else {
        ...
      }
    } else {
      // fail code
    }

   I.e., now SWIG_ConvertPtr can return new objects and you can
   identify the case and take care of the deallocation. Of course that
   also requires SWIG_ConvertPtr to return new result values, such as

      int SWIG_ConvertPtr(obj, ptr,...) {
        if (<obj is ok>) {
          if (<need new object>) {
            *ptr = <ptr to new allocated object>;
            return SWIG_NEWOBJ;
          } else {
            *ptr = <ptr to old object>;
            return SWIG_OLDOBJ;
          }
        } else {
          return SWIG_BADOBJ;
        }
      }

   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
   SWIG errors code.

   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
   allows to return the 'cast rank', for example, if you have this

       int food(double)
       int fooi(int);

   and you call

      food(1)   // cast rank '1'  (1 -> 1.0)
      fooi(1)   // cast rank '0'

   just use the SWIG_AddCast()/SWIG_CheckState()
*/

#define SWIG_OK                    (0)
#define SWIG_ERROR                 (-1)
#define SWIG_IsOK(r)               (r >= 0)
#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)

/* The CastRankLimit says how many bits are used for the cast rank */
#define SWIG_CASTRANKLIMIT         (1 << 8)
/* The NewMask denotes the object was created (using new/malloc) */
#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
/* The TmpMask is for in/out typemaps that use temporal objects */
#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
/* Simple returning values */
#define SWIG_BADOBJ                (SWIG_ERROR)
#define SWIG_OLDOBJ                (SWIG_OK)
#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
/* Check, add and del mask methods */
#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))

/* Cast-Rank Mode */
#if defined(SWIG_CASTRANK_MODE)
#  ifndef SWIG_TypeRank
#    define SWIG_TypeRank             unsigned long
#  endif
#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
#    define SWIG_MAXCASTRANK          (2)
#  endif
#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
SWIGINTERNINLINE int SWIG_AddCast(int r) {
  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
}
SWIGINTERNINLINE int SWIG_CheckState(int r) {
  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
}
#else /* no cast-rank mode */
#  define SWIG_AddCast(r) (r)
#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
#endif


#include <string.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef void *(*swig_converter_func)(void *, int *);
typedef struct swig_type_info *(*swig_dycast_func)(void **);

/* Structure to store information on one type */
typedef struct swig_type_info {
  const char             *name;			/* mangled name of this type */
  const char             *str;			/* human readable name of this type */
  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
  void                   *clientdata;		/* language specific type data */
  int                    owndata;		/* flag if the structure owns the clientdata */
} swig_type_info;

/* Structure to store a type and conversion function used for casting */
typedef struct swig_cast_info {
  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
  swig_converter_func     converter;		/* function to cast the void pointers */
  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
  struct swig_cast_info  *prev;			/* pointer to the previous cast */
} swig_cast_info;

/* Structure used to store module information
 * Each module generates one structure like this, and the runtime collects
 * all of these structures and stores them in a circularly linked list.*/
typedef struct swig_module_info {
  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
  size_t                 size;		        /* Number of types in this module */
  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
  swig_type_info         **type_initial;	/* Array of initially generated type structures */
  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
  void                    *clientdata;		/* Language specific module data */
} swig_module_info;

/*
  Compare two type names skipping the space characters, therefore
  "char*" == "char *" and "Class<int>" == "Class<int >", etc.

  Return 0 when the two name types are equivalent, as in
  strncmp, but skipping ' '.
*/
SWIGRUNTIME int
SWIG_TypeNameComp(const char *f1, const char *l1,
		  const char *f2, const char *l2) {
  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
    while ((*f1 == ' ') && (f1 != l1)) ++f1;
    while ((*f2 == ' ') && (f2 != l2)) ++f2;
    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
  }
  return (int)((l1 - f1) - (l2 - f2));
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
*/
SWIGRUNTIME int
SWIG_TypeCmp(const char *nb, const char *tb) {
  int equiv = 1;
  const char* te = tb + strlen(tb);
  const char* ne = nb;
  while (equiv != 0 && *ne) {
    for (nb = ne; *ne; ++ne) {
      if (*ne == '|') break;
    }
    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
    if (*ne) ++ne;
  }
  return equiv;
}

/*
  Check type equivalence in a name list like <name1>|<name2>|...
  Return 0 if not equal, 1 if equal
*/
SWIGRUNTIME int
SWIG_TypeEquiv(const char *nb, const char *tb) {
  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
}

/*
  Check the typename
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char *c, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (strcmp(iter->type->name, c) == 0) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
*/
SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
  if (ty) {
    swig_cast_info *iter = ty->cast;
    while (iter) {
      if (iter->type == from) {
        if (iter == ty->cast)
          return iter;
        /* Move iter to the top of the linked list */
        iter->prev->next = iter->next;
        if (iter->next)
          iter->next->prev = iter->prev;
        iter->next = ty->cast;
        iter->prev = 0;
        if (ty->cast) ty->cast->prev = iter;
        ty->cast = iter;
        return iter;
      }
      iter = iter->next;
    }
  }
  return 0;
}

/*
  Cast a pointer up an inheritance hierarchy
*/
SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
}

/*
   Dynamic pointer casting. Down an inheritance hierarchy
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
  swig_type_info *lastty = ty;
  if (!ty || !ty->dcast) return ty;
  while (ty && (ty->dcast)) {
    ty = (*ty->dcast)(ptr);
    if (ty) lastty = ty;
  }
  return lastty;
}

/*
  Return the name associated with this type
*/
SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info *ty) {
  return ty->name;
}

/*
  Return the pretty name associated with this type,
  that is an unmangled type name in a form presentable to the user.
*/
SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info *type) {
  /* The "str" field contains the equivalent pretty names of the
     type, separated by vertical-bar characters.  We choose
     to print the last name, as it is often (?) the most
     specific. */
  if (!type) return NULL;
  if (type->str != NULL) {
    const char *last_name = type->str;
    const char *s;
    for (s = type->str; *s; s++)
      if (*s == '|') last_name = s+1;
    return last_name;
  }
  else
    return type->name;
}

/*
   Set the clientdata field for a type
*/
SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
  swig_cast_info *cast = ti->cast;
  /* if (ti->clientdata == clientdata) return; */
  ti->clientdata = clientdata;

  while (cast) {
    if (!cast->converter) {
      swig_type_info *tc = cast->type;
      if (!tc->clientdata) {
	SWIG_TypeClientData(tc, clientdata);
      }
    }
    cast = cast->next;
  }
}
SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
  SWIG_TypeClientData(ti, clientdata);
  ti->owndata = 1;
}

/*
  Search for a swig_type_info structure only by mangled name
  Search is a O(log #types)

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info *start,
                            swig_module_info *end,
		            const char *name) {
  swig_module_info *iter = start;
  do {
    if (iter->size) {
      size_t l = 0;
      size_t r = iter->size - 1;
      do {
	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	size_t i = (l + r) >> 1;
	const char *iname = iter->types[i]->name;
	if (iname) {
	  int compare = strcmp(name, iname);
	  if (compare == 0) {
	    return iter->types[i];
	  } else if (compare < 0) {
	    if (i) {
	      r = i - 1;
	    } else {
	      break;
	    }
	  } else if (compare > 0) {
	    l = i + 1;
	  }
	} else {
	  break; /* should never happen */
	}
      } while (l <= r);
    }
    iter = iter->next;
  } while (iter != end);
  return 0;
}

/*
  Search for a swig_type_info structure for either a mangled name or a human readable name.
  It first searches the mangled names of the types, which is a O(log #types)
  If a type is not found it then searches the human readable names, which is O(#types).

  We start searching at module start, and finish searching when start == end.
  Note: if start == end at the beginning of the function, we go all the way around
  the circular list.
*/
SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info *start,
                     swig_module_info *end,
		     const char *name) {
  /* STEP 1: Search the name field using binary search */
  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
  if (ret) {
    return ret;
  } else {
    /* STEP 2: If the type hasn't been found, do a complete search
       of the str field (the human readable name) */
    swig_module_info *iter = start;
    do {
      size_t i = 0;
      for (; i < iter->size; ++i) {
	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	  return iter->types[i];
      }
      iter = iter->next;
    } while (iter != end);
  }

  /* neither found a match */
  return 0;
}

/*
   Pack binary data into a string
*/
SWIGRUNTIME char *
SWIG_PackData(char *c, void *ptr, size_t sz) {
  static const char hex[17] = "0123456789abcdef";
  const unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu =  u + sz;
  for (; u != eu; ++u) {
    unsigned char uu = *u;
    *(c++) = hex[(uu & 0xf0) >> 4];
    *(c++) = hex[uu & 0xf];
  }
  return c;
}

/*
   Unpack binary data from a string
*/
SWIGRUNTIME const char *
SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
  unsigned char *u = (unsigned char *) ptr;
  const unsigned char *eu = u + sz;
  for (; u != eu; ++u) {
    char d = *(c++);
    unsigned char uu;
    if ((d >= '0') && (d <= '9'))
      uu = (unsigned char)((d - '0') << 4);
    else if ((d >= 'a') && (d <= 'f'))
      uu = (unsigned char)((d - ('a'-10)) << 4);
    else
      return (char *) 0;
    d = *(c++);
    if ((d >= '0') && (d <= '9'))
      uu |= (unsigned char)(d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      uu |= (unsigned char)(d - ('a'-10));
    else
      return (char *) 0;
    *u = uu;
  }
  return c;
}

/*
   Pack 'void *' into a string buffer.
*/
SWIGRUNTIME char *
SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
  char *r = buff;
  if ((2*sizeof(void *) + 2) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,&ptr,sizeof(void *));
  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
  strcpy(r,name);
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      *ptr = (void *) 0;
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sizeof(void *));
}

SWIGRUNTIME char *
SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
  char *r = buff;
  size_t lname = (name ? strlen(name) : 0);
  if ((2*sz + 2 + lname) > bsz) return 0;
  *(r++) = '_';
  r = SWIG_PackData(r,ptr,sz);
  if (lname) {
    strncpy(r,name,lname+1);
  } else {
    *r = 0;
  }
  return buff;
}

SWIGRUNTIME const char *
SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
  if (*c != '_') {
    if (strcmp(c,"NULL") == 0) {
      memset(ptr,0,sz);
      return name;
    } else {
      return 0;
    }
  }
  return SWIG_UnpackData(++c,ptr,sz);
}

#ifdef __cplusplus
}
#endif

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13



/* Compatibility macros for Python 3 */
#if PY_VERSION_HEX >= 0x03000000

#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
#define PyInt_Check(x) PyLong_Check(x)
#define PyInt_AsLong(x) PyLong_AsLong(x)
#define PyInt_FromLong(x) PyLong_FromLong(x)
#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
#define PyString_Check(name) PyBytes_Check(name)
#define PyString_FromString(x) PyUnicode_FromString(x)
#define PyString_Format(fmt, args)  PyUnicode_Format(fmt, args)
#define PyString_AsString(str) PyBytes_AsString(str)
#define PyString_Size(str) PyBytes_Size(str)	
#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)

#endif

#ifndef Py_TYPE
#  define Py_TYPE(op) ((op)->ob_type)
#endif

/* SWIG APIs for compatibility of both Python 2 & 3 */

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_FromFormat PyUnicode_FromFormat
#else
#  define SWIG_Python_str_FromFormat PyString_FromFormat
#endif


/* Warning: This function will allocate a new string in Python 3,
 * so please call SWIG_Python_str_DelForPy3(x) to free the space.
 */
SWIGINTERN char*
SWIG_Python_str_AsChar(PyObject *str)
{
#if PY_VERSION_HEX >= 0x03000000
  char *newstr = 0;
  str = PyUnicode_AsUTF8String(str);
  if (str) {
    char *cstr;
    Py_ssize_t len;
    PyBytes_AsStringAndSize(str, &cstr, &len);
    newstr = (char *) malloc(len+1);
    memcpy(newstr, cstr, len+1);
    Py_XDECREF(str);
  }
  return newstr;
#else
  return PyString_AsString(str);
#endif
}

#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
#else
#  define SWIG_Python_str_DelForPy3(x) 
#endif


SWIGINTERN PyObject*
SWIG_Python_str_FromChar(const char *c)
{
#if PY_VERSION_HEX >= 0x03000000
  return PyUnicode_FromString(c); 
#else
  return PyString_FromString(c);
#endif
}

#ifndef PyObject_DEL
# define PyObject_DEL PyObject_Del
#endif

// SWIGPY_USE_CAPSULE is no longer used within SWIG itself, but some user
// interface files check for it.
# define SWIGPY_USE_CAPSULE
# define SWIGPY_CAPSULE_NAME ("swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)

#if PY_VERSION_HEX < 0x03020000
#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
#define Py_hash_t long
#endif

/* -----------------------------------------------------------------------------
 * error manipulation
 * ----------------------------------------------------------------------------- */

SWIGRUNTIME PyObject*
SWIG_Python_ErrorType(int code) {
  PyObject* type = 0;
  switch(code) {
  case SWIG_MemoryError:
    type = PyExc_MemoryError;
    break;
  case SWIG_IOError:
    type = PyExc_IOError;
    break;
  case SWIG_RuntimeError:
    type = PyExc_RuntimeError;
    break;
  case SWIG_IndexError:
    type = PyExc_IndexError;
    break;
  case SWIG_TypeError:
    type = PyExc_TypeError;
    break;
  case SWIG_DivisionByZero:
    type = PyExc_ZeroDivisionError;
    break;
  case SWIG_OverflowError:
    type = PyExc_OverflowError;
    break;
  case SWIG_SyntaxError:
    type = PyExc_SyntaxError;
    break;
  case SWIG_ValueError:
    type = PyExc_ValueError;
    break;
  case SWIG_SystemError:
    type = PyExc_SystemError;
    break;
  case SWIG_AttributeError:
    type = PyExc_AttributeError;
    break;
  default:
    type = PyExc_RuntimeError;
  }
  return type;
}


SWIGRUNTIME void
SWIG_Python_AddErrorMsg(const char* mesg)
{
  PyObject *type = 0;
  PyObject *value = 0;
  PyObject *traceback = 0;

  if (PyErr_Occurred())
    PyErr_Fetch(&type, &value, &traceback);
  if (value) {
    PyObject *old_str = PyObject_Str(value);
    const char *tmp = SWIG_Python_str_AsChar(old_str);
    PyErr_Clear();
    Py_XINCREF(type);
    if (tmp)
      PyErr_Format(type, "%s %s", tmp, mesg);
    else
      PyErr_Format(type, "%s", mesg);
    SWIG_Python_str_DelForPy3(tmp);
    Py_DECREF(old_str);
    Py_DECREF(value);
  } else {
    PyErr_SetString(PyExc_RuntimeError, mesg);
  }
}

SWIGRUNTIME int
SWIG_Python_TypeErrorOccurred(PyObject *obj)
{
  PyObject *error;
  if (obj)
    return 0;
  error = PyErr_Occurred();
  return error && PyErr_GivenExceptionMatches(error, PyExc_TypeError);
}

SWIGRUNTIME void
SWIG_Python_RaiseOrModifyTypeError(const char *message)
{
  if (SWIG_Python_TypeErrorOccurred(NULL)) {
    /* Use existing TypeError to preserve stacktrace and enhance with given message */
    PyObject *newvalue;
    PyObject *type = NULL, *value = NULL, *traceback = NULL;
    PyErr_Fetch(&type, &value, &traceback);
#if PY_VERSION_HEX >= 0x03000000
    newvalue = PyUnicode_FromFormat("%S\nAdditional information:\n%s", value, message);
#else
    newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message);
#endif
    Py_XDECREF(value);
    PyErr_Restore(type, newvalue, traceback);
  } else {
    /* Raise TypeError using given message */
    PyErr_SetString(PyExc_TypeError, message);
  }
}

#if defined(SWIG_PYTHON_NO_THREADS)
#  if defined(SWIG_PYTHON_THREADS)
#    undef SWIG_PYTHON_THREADS
#  endif
#endif
#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
#  if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
#    define SWIG_PYTHON_USE_GIL
#  endif
#  if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
#    ifndef SWIG_PYTHON_INITIALIZE_THREADS
#     define SWIG_PYTHON_INITIALIZE_THREADS  PyEval_InitThreads() 
#    endif
#    ifdef __cplusplus /* C++ code */
       class SWIG_Python_Thread_Block {
         bool status;
         PyGILState_STATE state;
       public:
         void end() { if (status) { PyGILState_Release(state); status = false;} }
         SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
         ~SWIG_Python_Thread_Block() { end(); }
       };
       class SWIG_Python_Thread_Allow {
         bool status;
         PyThreadState *save;
       public:
         void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
         SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
         ~SWIG_Python_Thread_Allow() { end(); }
       };
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   SWIG_Python_Thread_Block _swig_thread_block
#      define SWIG_PYTHON_THREAD_END_BLOCK     _swig_thread_block.end()
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   SWIG_Python_Thread_Allow _swig_thread_allow
#      define SWIG_PYTHON_THREAD_END_ALLOW     _swig_thread_allow.end()
#    else /* C code */
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK   PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
#      define SWIG_PYTHON_THREAD_END_BLOCK     PyGILState_Release(_swig_thread_block)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW   PyThreadState *_swig_thread_allow = PyEval_SaveThread()
#      define SWIG_PYTHON_THREAD_END_ALLOW     PyEval_RestoreThread(_swig_thread_allow)
#    endif
#  else /* Old thread way, not implemented, user must provide it */
#    if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
#      define SWIG_PYTHON_INITIALIZE_THREADS
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
#      define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
#      define SWIG_PYTHON_THREAD_END_BLOCK
#    endif
#    if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
#      define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#    endif
#    if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
#      define SWIG_PYTHON_THREAD_END_ALLOW
#    endif
#  endif
#else /* No thread support */
#  define SWIG_PYTHON_INITIALIZE_THREADS
#  define SWIG_PYTHON_THREAD_BEGIN_BLOCK
#  define SWIG_PYTHON_THREAD_END_BLOCK
#  define SWIG_PYTHON_THREAD_BEGIN_ALLOW
#  define SWIG_PYTHON_THREAD_END_ALLOW
#endif

/* -----------------------------------------------------------------------------
 * Python API portion that goes into the runtime
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#endif

/* -----------------------------------------------------------------------------
 * Constant declarations
 * ----------------------------------------------------------------------------- */

/* Constant Types */
#define SWIG_PY_POINTER 4
#define SWIG_PY_BINARY  5

/* Constant information structure */
typedef struct swig_const_info {
  int type;
  const char *name;
  long lvalue;
  double dvalue;
  void   *pvalue;
  swig_type_info **ptype;
} swig_const_info;

#ifdef __cplusplus
}
#endif


/* -----------------------------------------------------------------------------
 * pyrun.swg
 *
 * This file contains the runtime support for Python modules
 * and includes code for managing global variables and pointer
 * type checking.
 *
 * ----------------------------------------------------------------------------- */

#if PY_VERSION_HEX < 0x02070000 /* 2.7.0 */
# error "This version of SWIG only supports Python >= 2.7"
#endif

#if PY_VERSION_HEX >= 0x03000000 && PY_VERSION_HEX < 0x03020000
# error "This version of SWIG only supports Python 3 >= 3.2"
#endif

/* Common SWIG API */

/* for raw pointers */
#define SWIG_Python_ConvertPtr(obj, pptr, type, flags)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
#define SWIG_ConvertPtr(obj, pptr, type, flags)         SWIG_Python_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own)  SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)

#ifdef SWIGPYTHON_BUILTIN
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(self, ptr, type, flags)
#else
#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
#endif

#define SWIG_InternalNewPointerObj(ptr, type, flags)	SWIG_Python_NewPointerObj(NULL, ptr, type, flags)

#define SWIG_CheckImplicit(ty)                          SWIG_Python_CheckImplicit(ty) 
#define SWIG_AcquirePtr(ptr, src)                       SWIG_Python_AcquirePtr(ptr, src)
#define swig_owntype                                    int

/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)

/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags)           SWIG_NewPointerObj(ptr, type, flags)

/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Python_NewPointerObj(NULL, ptr, type, 0)

/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Python_NewPackedObj(ptr, sz, type)


/* Runtime API */

#define SWIG_GetModule(clientdata)                      SWIG_Python_GetModule(clientdata)
#define SWIG_SetModule(clientdata, pointer)             SWIG_Python_SetModule(pointer)
#define SWIG_NewClientData(obj)                         SwigPyClientData_New(obj)

#define SWIG_SetErrorObj                                SWIG_Python_SetErrorObj                            
#define SWIG_SetErrorMsg                        	SWIG_Python_SetErrorMsg				   
#define SWIG_ErrorType(code)                    	SWIG_Python_ErrorType(code)                        
#define SWIG_Error(code, msg)            		SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg) 
#define SWIG_fail                        		goto fail					   


/* Runtime API implementation */

/* Error manipulation */

SWIGINTERN void 
SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK; 
  PyErr_SetObject(errtype, obj);
  Py_DECREF(obj);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

SWIGINTERN void 
SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
  SWIG_PYTHON_THREAD_BEGIN_BLOCK;
  PyErr_SetString(errtype, msg);
  SWIG_PYTHON_THREAD_END_BLOCK;
}

#define SWIG_Python_Raise(obj, type, desc)  SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)

/* Set a constant value */

#if defined(SWIGPYTHON_BUILTIN)

SWIGINTERN void
SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
  PyObject *s = PyString_InternFromString(key);
  PyList_Append(seq, s);
  Py_DECREF(s);
}

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);
  if (public_interface)
    SwigPyBuiltin_AddPublicSymbol(public_interface, name);
}

#else

SWIGINTERN void
SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {   
  PyDict_SetItemString(d, name, obj);
  Py_DECREF(obj);                            
}

#endif

/* Append a value to the result obj */

SWIGINTERN PyObject*
SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
  if (!result) {
    result = obj;
  } else if (result == Py_None) {
    Py_DECREF(result);
    result = obj;
  } else {
    if (!PyList_Check(result)) {
      PyObject *o2 = result;
      result = PyList_New(1);
      PyList_SetItem(result, 0, o2);
    }
    PyList_Append(result,obj);
    Py_DECREF(obj);
  }
  return result;
}

/* Unpack the argument tuple */

SWIGINTERN Py_ssize_t
SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
{
  if (!args) {
    if (!min && !max) {
      return 1;
    } else {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none", 
		   name, (min == max ? "" : "at least "), (int)min);
      return 0;
    }
  }  
  if (!PyTuple_Check(args)) {
    if (min <= 1 && max >= 1) {
      Py_ssize_t i;
      objs[0] = args;
      for (i = 1; i < max; ++i) {
	objs[i] = 0;
      }
      return 2;
    }
    PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
    return 0;
  } else {
    Py_ssize_t l = PyTuple_GET_SIZE(args);
    if (l < min) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at least "), (int)min, (int)l);
      return 0;
    } else if (l > max) {
      PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d", 
		   name, (min == max ? "" : "at most "), (int)max, (int)l);
      return 0;
    } else {
      Py_ssize_t i;
      for (i = 0; i < l; ++i) {
	objs[i] = PyTuple_GET_ITEM(args, i);
      }
      for (; l < max; ++l) {
	objs[l] = 0;
      }
      return i + 1;
    }    
  }
}

/* A functor is a function object with one single object argument */
#define SWIG_Python_CallFunctor(functor, obj)	        PyObject_CallFunctionObjArgs(functor, obj, NULL);

/*
  Helper for static pointer initialization for both C and C++ code, for example
  static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
*/
#ifdef __cplusplus
#define SWIG_STATIC_POINTER(var)  var
#else
#define SWIG_STATIC_POINTER(var)  var = 0; if (!var) var
#endif

/* -----------------------------------------------------------------------------
 * Pointer declarations
 * ----------------------------------------------------------------------------- */

/* Flags for new pointer objects */
#define SWIG_POINTER_NOSHADOW       (SWIG_POINTER_OWN      << 1)
#define SWIG_POINTER_NEW            (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)

#define SWIG_POINTER_IMPLICIT_CONV  (SWIG_POINTER_DISOWN   << 1)

#define SWIG_BUILTIN_TP_INIT	    (SWIG_POINTER_OWN << 2)
#define SWIG_BUILTIN_INIT	    (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)

#ifdef __cplusplus
extern "C" {
#endif

/* The python void return value */

SWIGRUNTIMEINLINE PyObject * 
SWIG_Py_Void(void)
{
  PyObject *none = Py_None;
  Py_INCREF(none);
  return none;
}

/* SwigPyClientData */

typedef struct {
  PyObject *klass;
  PyObject *newraw;
  PyObject *newargs;
  PyObject *destroy;
  int delargs;
  int implicitconv;
  PyTypeObject *pytype;
} SwigPyClientData;

SWIGRUNTIMEINLINE int 
SWIG_Python_CheckImplicit(swig_type_info *ty)
{
  SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
  int fail = data ? data->implicitconv : 0;
  if (fail)
    PyErr_SetString(PyExc_TypeError, "Implicit conversion is prohibited for explicit constructors.");
  return fail;
}

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_ExceptionType(swig_type_info *desc) {
  SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
  PyObject *klass = data ? data->klass : 0;
  return (klass ? klass : PyExc_RuntimeError);
}


SWIGRUNTIME SwigPyClientData * 
SwigPyClientData_New(PyObject* obj)
{
  if (!obj) {
    return 0;
  } else {
    SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
    /* the klass element */
    data->klass = obj;
    Py_INCREF(data->klass);
    /* the newraw method and newargs arguments used to create a new raw instance */
    if (PyClass_Check(obj)) {
      data->newraw = 0;
      data->newargs = obj;
      Py_INCREF(obj);
    } else {
      data->newraw = PyObject_GetAttrString(data->klass, "__new__");
      if (data->newraw) {
	Py_INCREF(data->newraw);
	data->newargs = PyTuple_New(1);
	PyTuple_SetItem(data->newargs, 0, obj);
      } else {
	data->newargs = obj;
      }
      Py_INCREF(data->newargs);
    }
    /* the destroy method, aka as the C++ delete method */
    data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__");
    if (PyErr_Occurred()) {
      PyErr_Clear();
      data->destroy = 0;
    }
    if (data->destroy) {
      int flags;
      Py_INCREF(data->destroy);
      flags = PyCFunction_GET_FLAGS(data->destroy);
      data->delargs = !(flags & (METH_O));
    } else {
      data->delargs = 0;
    }
    data->implicitconv = 0;
    data->pytype = 0;
    return data;
  }
}

SWIGRUNTIME void 
SwigPyClientData_Del(SwigPyClientData *data) {
  Py_XDECREF(data->newraw);
  Py_XDECREF(data->newargs);
  Py_XDECREF(data->destroy);
}

/* =============== SwigPyObject =====================*/

typedef struct {
  PyObject_HEAD
  void *ptr;
  swig_type_info *ty;
  int own;
  PyObject *next;
#ifdef SWIGPYTHON_BUILTIN
  PyObject *dict;
#endif
} SwigPyObject;


#ifdef SWIGPYTHON_BUILTIN

SWIGRUNTIME PyObject *
SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;

  if (!sobj->dict)
    sobj->dict = PyDict_New();

  Py_INCREF(sobj->dict);
  return sobj->dict;
}

#endif

SWIGRUNTIME PyObject *
SwigPyObject_long(SwigPyObject *v)
{
  return PyLong_FromVoidPtr(v->ptr);
}

SWIGRUNTIME PyObject *
SwigPyObject_format(const char* fmt, SwigPyObject *v)
{
  PyObject *res = NULL;
  PyObject *args = PyTuple_New(1);
  if (args) {
    if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
      PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
      if (ofmt) {
#if PY_VERSION_HEX >= 0x03000000
	res = PyUnicode_Format(ofmt,args);
#else
	res = PyString_Format(ofmt,args);
#endif
	Py_DECREF(ofmt);
      }
      Py_DECREF(args);
    }
  }
  return res;
}

SWIGRUNTIME PyObject *
SwigPyObject_oct(SwigPyObject *v)
{
  return SwigPyObject_format("%o",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_hex(SwigPyObject *v)
{
  return SwigPyObject_format("%x",v);
}

SWIGRUNTIME PyObject *
SwigPyObject_repr(SwigPyObject *v)
{
  const char *name = SWIG_TypePrettyName(v->ty);
  PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
  if (v->next) {
    PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
# if PY_VERSION_HEX >= 0x03000000
    PyObject *joined = PyUnicode_Concat(repr, nrep);
    Py_DecRef(repr);
    Py_DecRef(nrep);
    repr = joined;
# else
    PyString_ConcatAndDel(&repr,nrep);
# endif
  }
  return repr;  
}

/* We need a version taking two PyObject* parameters so it's a valid
 * PyCFunction to use in swigobject_methods[]. */
SWIGRUNTIME PyObject *
SwigPyObject_repr2(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
{
  return SwigPyObject_repr((SwigPyObject*)v);
}

SWIGRUNTIME int
SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
{
  void *i = v->ptr;
  void *j = w->ptr;
  return (i < j) ? -1 : ((i > j) ? 1 : 0);
}

/* Added for Python 3.x, would it also be useful for Python 2.x? */
SWIGRUNTIME PyObject*
SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
{
  PyObject* res;
  if( op != Py_EQ && op != Py_NE ) {
    Py_INCREF(Py_NotImplemented);
    return Py_NotImplemented;
  }
  res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
  return res;  
}


SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);

#ifdef SWIGPYTHON_BUILTIN
static swig_type_info *SwigPyObject_stype = 0;
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
    SwigPyClientData *cd;
    assert(SwigPyObject_stype);
    cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
    assert(cd);
    assert(cd->pytype);
    return cd->pytype;
}
#else
SWIGRUNTIME PyTypeObject*
SwigPyObject_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
  return type;
}
#endif

SWIGRUNTIMEINLINE int
SwigPyObject_Check(PyObject *op) {
#ifdef SWIGPYTHON_BUILTIN
  PyTypeObject *target_tp = SwigPyObject_type();
  if (PyType_IsSubtype(op->ob_type, target_tp))
    return 1;
  return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
#else
  return (Py_TYPE(op) == SwigPyObject_type())
    || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
#endif
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own);

SWIGRUNTIME void
SwigPyObject_dealloc(PyObject *v)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  PyObject *next = sobj->next;
  if (sobj->own == SWIG_POINTER_OWN) {
    swig_type_info *ty = sobj->ty;
    SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
    PyObject *destroy = data ? data->destroy : 0;
    if (destroy) {
      /* destroy is always a VARARGS method */
      PyObject *res;

      /* PyObject_CallFunction() has the potential to silently drop
         the active exception.  In cases of unnamed temporary
         variable or where we just finished iterating over a generator
         StopIteration will be active right now, and this needs to
         remain true upon return from SwigPyObject_dealloc.  So save
         and restore. */
      
      PyObject *type = NULL, *value = NULL, *traceback = NULL;
      PyErr_Fetch(&type, &value, &traceback);

      if (data->delargs) {
        /* we need to create a temporary object to carry the destroy operation */
        PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
        res = SWIG_Python_CallFunctor(destroy, tmp);
        Py_DECREF(tmp);
      } else {
        PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
        PyObject *mself = PyCFunction_GET_SELF(destroy);
        res = ((*meth)(mself, v));
      }
      if (!res)
        PyErr_WriteUnraisable(destroy);

      PyErr_Restore(type, value, traceback);

      Py_XDECREF(res);
    } 
#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
    else {
      const char *name = SWIG_TypePrettyName(ty);
      printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
    }
#endif
  } 
  Py_XDECREF(next);
  PyObject_DEL(v);
}

SWIGRUNTIME PyObject* 
SwigPyObject_append(PyObject* v, PyObject* next)
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (!SwigPyObject_Check(next)) {
    PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
    return NULL;
  }
  sobj->next = next;
  Py_INCREF(next);
  return SWIG_Py_Void();
}

SWIGRUNTIME PyObject* 
SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *) v;
  if (sobj->next) {    
    Py_INCREF(sobj->next);
    return sobj->next;
  } else {
    return SWIG_Py_Void();
  }
}

SWIGINTERN PyObject*
SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = 0;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
{
  SwigPyObject *sobj = (SwigPyObject *)v;
  sobj->own = SWIG_POINTER_OWN;
  return SWIG_Py_Void();
}

SWIGINTERN PyObject*
SwigPyObject_own(PyObject *v, PyObject *args)
{
  PyObject *val = 0;
  if (!PyArg_UnpackTuple(args, "own", 0, 1, &val)) {
    return NULL;
  } else {
    SwigPyObject *sobj = (SwigPyObject *)v;
    PyObject *obj = PyBool_FromLong(sobj->own);
    if (val) {
      if (PyObject_IsTrue(val)) {
        SwigPyObject_acquire(v,args);
      } else {
        SwigPyObject_disown(v,args);
      }
    } 
    return obj;
  }
}

static PyMethodDef
swigobject_methods[] = {
  {"disown",  SwigPyObject_disown,  METH_NOARGS,  "releases ownership of the pointer"},
  {"acquire", SwigPyObject_acquire, METH_NOARGS,  "acquires ownership of the pointer"},
  {"own",     SwigPyObject_own,     METH_VARARGS, "returns/sets ownership of the pointer"},
  {"append",  SwigPyObject_append,  METH_O,       "appends another 'this' object"},
  {"next",    SwigPyObject_next,    METH_NOARGS,  "returns the next 'this' object"},
  {"__repr__",SwigPyObject_repr2,   METH_NOARGS,  "returns object representation"},
  {0, 0, 0, 0}  
};

SWIGRUNTIME PyTypeObject*
SwigPyObject_TypeOnce(void) {
  static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";

  static PyNumberMethods SwigPyObject_as_number = {
    (binaryfunc)0, /*nb_add*/
    (binaryfunc)0, /*nb_subtract*/
    (binaryfunc)0, /*nb_multiply*/
    /* nb_divide removed in Python 3 */
#if PY_VERSION_HEX < 0x03000000
    (binaryfunc)0, /*nb_divide*/
#endif
    (binaryfunc)0, /*nb_remainder*/
    (binaryfunc)0, /*nb_divmod*/
    (ternaryfunc)0,/*nb_power*/
    (unaryfunc)0,  /*nb_negative*/
    (unaryfunc)0,  /*nb_positive*/
    (unaryfunc)0,  /*nb_absolute*/
    (inquiry)0,    /*nb_nonzero*/
    0,		   /*nb_invert*/
    0,		   /*nb_lshift*/
    0,		   /*nb_rshift*/
    0,		   /*nb_and*/
    0,		   /*nb_xor*/
    0,		   /*nb_or*/
#if PY_VERSION_HEX < 0x03000000
    0,   /*nb_coerce*/
#endif
    (unaryfunc)SwigPyObject_long, /*nb_int*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_long, /*nb_long*/
#else
    0, /*nb_reserved*/
#endif
    (unaryfunc)0,                 /*nb_float*/
#if PY_VERSION_HEX < 0x03000000
    (unaryfunc)SwigPyObject_oct,  /*nb_oct*/
    (unaryfunc)SwigPyObject_hex,  /*nb_hex*/
#endif
#if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
#elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
#else
    0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
#endif
  };

  static PyTypeObject swigpyobject_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyObject",                       /* tp_name */
      sizeof(SwigPyObject),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyObject_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX >= 0x03000000
      0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
#else
      (cmpfunc)SwigPyObject_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyObject_repr,          /* tp_repr */
      &SwigPyObject_as_number,              /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      0,                                    /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigobject_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      swigobject_methods,                   /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpyobject_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpyobject_type) < 0)
      return NULL;
  }
  return &swigpyobject_type;
}

SWIGRUNTIME PyObject *
SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
{
  SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
  if (sobj) {
    sobj->ptr  = ptr;
    sobj->ty   = ty;
    sobj->own  = own;
    sobj->next = 0;
  }
  return (PyObject *)sobj;
}

/* -----------------------------------------------------------------------------
 * Implements a simple Swig Packed type, and use it instead of string
 * ----------------------------------------------------------------------------- */

typedef struct {
  PyObject_HEAD
  void *pack;
  swig_type_info *ty;
  size_t size;
} SwigPyPacked;

SWIGRUNTIME PyObject *
SwigPyPacked_repr(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
    return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
  }  
}

SWIGRUNTIME PyObject *
SwigPyPacked_str(SwigPyPacked *v)
{
  char result[SWIG_BUFFER_SIZE];
  if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
    return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
  } else {
    return SWIG_Python_str_FromChar(v->ty->name);
  }  
}

SWIGRUNTIME int
SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
{
  size_t i = v->size;
  size_t j = w->size;
  int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
  return s ? s : strncmp((const char *)v->pack, (const char *)w->pack, 2*v->size);
}

SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);

SWIGRUNTIME PyTypeObject*
SwigPyPacked_type(void) {
  static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
  return type;
}

SWIGRUNTIMEINLINE int
SwigPyPacked_Check(PyObject *op) {
  return ((op)->ob_type == SwigPyPacked_TypeOnce()) 
    || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
}

SWIGRUNTIME void
SwigPyPacked_dealloc(PyObject *v)
{
  if (SwigPyPacked_Check(v)) {
    SwigPyPacked *sobj = (SwigPyPacked *) v;
    free(sobj->pack);
  }
  PyObject_DEL(v);
}

SWIGRUNTIME PyTypeObject*
SwigPyPacked_TypeOnce(void) {
  static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
  static PyTypeObject swigpypacked_type;
  static int type_init = 0;
  if (!type_init) {
    const PyTypeObject tmp = {
#if PY_VERSION_HEX>=0x03000000
      PyVarObject_HEAD_INIT(NULL, 0)
#else
      PyObject_HEAD_INIT(NULL)
      0,                                    /* ob_size */
#endif
      "SwigPyPacked",                       /* tp_name */
      sizeof(SwigPyPacked),                 /* tp_basicsize */
      0,                                    /* tp_itemsize */
      (destructor)SwigPyPacked_dealloc,     /* tp_dealloc */
      0,                                    /* tp_print */
      (getattrfunc)0,                       /* tp_getattr */
      (setattrfunc)0,                       /* tp_setattr */
#if PY_VERSION_HEX>=0x03000000
      0, /* tp_reserved in 3.0.1 */
#else
      (cmpfunc)SwigPyPacked_compare,        /* tp_compare */
#endif
      (reprfunc)SwigPyPacked_repr,          /* tp_repr */
      0,                                    /* tp_as_number */
      0,                                    /* tp_as_sequence */
      0,                                    /* tp_as_mapping */
      (hashfunc)0,                          /* tp_hash */
      (ternaryfunc)0,                       /* tp_call */
      (reprfunc)SwigPyPacked_str,           /* tp_str */
      PyObject_GenericGetAttr,              /* tp_getattro */
      0,                                    /* tp_setattro */
      0,                                    /* tp_as_buffer */
      Py_TPFLAGS_DEFAULT,                   /* tp_flags */
      swigpacked_doc,                       /* tp_doc */
      0,                                    /* tp_traverse */
      0,                                    /* tp_clear */
      0,                                    /* tp_richcompare */
      0,                                    /* tp_weaklistoffset */
      0,                                    /* tp_iter */
      0,                                    /* tp_iternext */
      0,                                    /* tp_methods */
      0,                                    /* tp_members */
      0,                                    /* tp_getset */
      0,                                    /* tp_base */
      0,                                    /* tp_dict */
      0,                                    /* tp_descr_get */
      0,                                    /* tp_descr_set */
      0,                                    /* tp_dictoffset */
      0,                                    /* tp_init */
      0,                                    /* tp_alloc */
      0,                                    /* tp_new */
      0,                                    /* tp_free */
      0,                                    /* tp_is_gc */
      0,                                    /* tp_bases */
      0,                                    /* tp_mro */
      0,                                    /* tp_cache */
      0,                                    /* tp_subclasses */
      0,                                    /* tp_weaklist */
      0,                                    /* tp_del */
      0,                                    /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
      0,                                    /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
      0,                                    /* tp_allocs */
      0,                                    /* tp_frees */
      0,                                    /* tp_maxalloc */
      0,                                    /* tp_prev */
      0                                     /* tp_next */
#endif
    };
    swigpypacked_type = tmp;
    type_init = 1;
    if (PyType_Ready(&swigpypacked_type) < 0)
      return NULL;
  }
  return &swigpypacked_type;
}

SWIGRUNTIME PyObject *
SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
{
  SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
  if (sobj) {
    void *pack = malloc(size);
    if (pack) {
      memcpy(pack, ptr, size);
      sobj->pack = pack;
      sobj->ty   = ty;
      sobj->size = size;
    } else {
      PyObject_DEL((PyObject *) sobj);
      sobj = 0;
    }
  }
  return (PyObject *) sobj;
}

SWIGRUNTIME swig_type_info *
SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
{
  if (SwigPyPacked_Check(obj)) {
    SwigPyPacked *sobj = (SwigPyPacked *)obj;
    if (sobj->size != size) return 0;
    memcpy(ptr, sobj->pack, size);
    return sobj->ty;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * pointers/data manipulation
 * ----------------------------------------------------------------------------- */

static PyObject *Swig_This_global = NULL;

SWIGRUNTIME PyObject *
SWIG_This(void)
{
  if (Swig_This_global == NULL)
    Swig_This_global = SWIG_Python_str_FromChar("this");
  return Swig_This_global;
}

/* #define SWIG_PYTHON_SLOW_GETSET_THIS */

/* TODO: I don't know how to implement the fast getset in Python 3 right now */
#if PY_VERSION_HEX>=0x03000000
#define SWIG_PYTHON_SLOW_GETSET_THIS 
#endif

SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj) 
{
  PyObject *obj;

  if (SwigPyObject_Check(pyobj))
    return (SwigPyObject *) pyobj;

#ifdef SWIGPYTHON_BUILTIN
  (void)obj;
# ifdef PyWeakref_CheckProxy
  if (PyWeakref_CheckProxy(pyobj)) {
    pyobj = PyWeakref_GET_OBJECT(pyobj);
    if (pyobj && SwigPyObject_Check(pyobj))
      return (SwigPyObject*) pyobj;
  }
# endif
  return NULL;
#else

  obj = 0;

#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
  if (PyInstance_Check(pyobj)) {
    obj = _PyInstance_Lookup(pyobj, SWIG_This());      
  } else {
    PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
    if (dictptr != NULL) {
      PyObject *dict = *dictptr;
      obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
    } else {
#ifdef PyWeakref_CheckProxy
      if (PyWeakref_CheckProxy(pyobj)) {
	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
      }
#endif
      obj = PyObject_GetAttr(pyobj,SWIG_This());
      if (obj) {
	Py_DECREF(obj);
      } else {
	if (PyErr_Occurred()) PyErr_Clear();
	return 0;
      }
    }
  }
#else
  obj = PyObject_GetAttr(pyobj,SWIG_This());
  if (obj) {
    Py_DECREF(obj);
  } else {
    if (PyErr_Occurred()) PyErr_Clear();
    return 0;
  }
#endif
  if (obj && !SwigPyObject_Check(obj)) {
    /* a PyObject is called 'this', try to get the 'real this'
       SwigPyObject from it */ 
    return SWIG_Python_GetSwigThis(obj);
  }
  return (SwigPyObject *)obj;
#endif
}

/* Acquire a pointer value */

SWIGRUNTIME int
SWIG_Python_AcquirePtr(PyObject *obj, int own) {
  if (own == SWIG_POINTER_OWN) {
    SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
    if (sobj) {
      int oldown = sobj->own;
      sobj->own = own;
      return oldown;
    }
  }
  return 0;
}

/* Convert a pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
  int res;
  SwigPyObject *sobj;
  int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;

  if (!obj)
    return SWIG_ERROR;
  if (obj == Py_None && !implicit_conv) {
    if (ptr)
      *ptr = 0;
    return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
  }

  res = SWIG_ERROR;

  sobj = SWIG_Python_GetSwigThis(obj);
  if (own)
    *own = 0;
  while (sobj) {
    void *vptr = sobj->ptr;
    if (ty) {
      swig_type_info *to = sobj->ty;
      if (to == ty) {
        /* no type cast needed */
        if (ptr) *ptr = vptr;
        break;
      } else {
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) {
          sobj = (SwigPyObject *)sobj->next;
        } else {
          if (ptr) {
            int newmemory = 0;
            *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
            if (newmemory == SWIG_CAST_NEW_MEMORY) {
              assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
              if (own)
                *own = *own | SWIG_CAST_NEW_MEMORY;
            }
          }
          break;
        }
      }
    } else {
      if (ptr) *ptr = vptr;
      break;
    }
  }
  if (sobj) {
    if (own)
      *own = *own | sobj->own;
    if (flags & SWIG_POINTER_DISOWN) {
      sobj->own = 0;
    }
    res = SWIG_OK;
  } else {
    if (implicit_conv) {
      SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
      if (data && !data->implicitconv) {
        PyObject *klass = data->klass;
        if (klass) {
          PyObject *impconv;
          data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
          impconv = SWIG_Python_CallFunctor(klass, obj);
          data->implicitconv = 0;
          if (PyErr_Occurred()) {
            PyErr_Clear();
            impconv = 0;
          }
          if (impconv) {
            SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
            if (iobj) {
              void *vptr;
              res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
              if (SWIG_IsOK(res)) {
                if (ptr) {
                  *ptr = vptr;
                  /* transfer the ownership to 'ptr' */
                  iobj->own = 0;
                  res = SWIG_AddCast(res);
                  res = SWIG_AddNewMask(res);
                } else {
                  res = SWIG_AddCast(res);		    
                }
              }
            }
            Py_DECREF(impconv);
          }
        }
      }
      if (!SWIG_IsOK(res) && obj == Py_None) {
        if (ptr)
          *ptr = 0;
        if (PyErr_Occurred())
          PyErr_Clear();
        res = SWIG_OK;
      }
    }
  }
  return res;
}

/* Convert a function ptr value */

SWIGRUNTIME int
SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
  if (!PyCFunction_Check(obj)) {
    return SWIG_ConvertPtr(obj, ptr, ty, 0);
  } else {
    void *vptr = 0;
    swig_cast_info *tc;

    /* here we get the method pointer for callbacks */
    const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
    const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
    if (desc)
      desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
    if (!desc)
      return SWIG_ERROR;
    tc = SWIG_TypeCheck(desc,ty);
    if (tc) {
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
      assert(!newmemory); /* newmemory handling not yet implemented */
    } else {
      return SWIG_ERROR;
    }
    return SWIG_OK;
  }
}

/* Convert a packed pointer value */

SWIGRUNTIME int
SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
  swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
  if (!to) return SWIG_ERROR;
  if (ty) {
    if (to != ty) {
      /* check type cast? */
      swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
      if (!tc) return SWIG_ERROR;
    }
  }
  return SWIG_OK;
}  

/* -----------------------------------------------------------------------------
 * Create a new pointer object
 * ----------------------------------------------------------------------------- */

/*
  Create a new instance object, without calling __init__, and set the
  'this' attribute.
*/

SWIGRUNTIME PyObject* 
SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
{
  PyObject *inst = 0;
  PyObject *newraw = data->newraw;
  if (newraw) {
    inst = PyObject_Call(newraw, data->newargs, NULL);
    if (inst) {
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
      PyObject **dictptr = _PyObject_GetDictPtr(inst);
      if (dictptr != NULL) {
	PyObject *dict = *dictptr;
	if (dict == NULL) {
	  dict = PyDict_New();
	  *dictptr = dict;
	  PyDict_SetItem(dict, SWIG_This(), swig_this);
	}
      }
#else
      PyObject *key = SWIG_This();
      PyObject_SetAttr(inst, key, swig_this);
#endif
    }
  } else {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *empty_args = PyTuple_New(0);
    if (empty_args) {
      PyObject *empty_kwargs = PyDict_New();
      if (empty_kwargs) {
        inst = ((PyTypeObject *)data->newargs)->tp_new((PyTypeObject *)data->newargs, empty_args, empty_kwargs);
        Py_DECREF(empty_kwargs);
        if (inst) {
          PyObject_SetAttr(inst, SWIG_This(), swig_this);
          Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
        }
      }
      Py_DECREF(empty_args);
    }
#else
    PyObject *dict = PyDict_New();
    if (dict) {
      PyDict_SetItem(dict, SWIG_This(), swig_this);
      inst = PyInstance_NewRaw(data->newargs, dict);
      Py_DECREF(dict);
    }
#endif
  }
  return inst;
}

SWIGRUNTIME void
SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
{
 PyObject *dict;
#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
 PyObject **dictptr = _PyObject_GetDictPtr(inst);
 if (dictptr != NULL) {
   dict = *dictptr;
   if (dict == NULL) {
     dict = PyDict_New();
     *dictptr = dict;
   }
   PyDict_SetItem(dict, SWIG_This(), swig_this);
   return;
 }
#endif
 dict = PyObject_GetAttrString(inst, "__dict__");
 PyDict_SetItem(dict, SWIG_This(), swig_this);
 Py_DECREF(dict);
} 


SWIGINTERN PyObject *
SWIG_Python_InitShadowInstance(PyObject *args) {
  PyObject *obj[2];
  if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
    return NULL;
  } else {
    SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
    if (sthis) {
      SwigPyObject_append((PyObject*) sthis, obj[1]);
    } else {
      SWIG_Python_SetSwigThis(obj[0], obj[1]);
    }
    return SWIG_Py_Void();
  }
}

/* Create a new pointer object */

SWIGRUNTIME PyObject *
SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
  SwigPyClientData *clientdata;
  PyObject * robj;
  int own;

  if (!ptr)
    return SWIG_Py_Void();

  clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
  own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
  if (clientdata && clientdata->pytype) {
    SwigPyObject *newobj;
    if (flags & SWIG_BUILTIN_TP_INIT) {
      newobj = (SwigPyObject*) self;
      if (newobj->ptr) {
        PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
        while (newobj->next)
	  newobj = (SwigPyObject *) newobj->next;
        newobj->next = next_self;
        newobj = (SwigPyObject *)next_self;
#ifdef SWIGPYTHON_BUILTIN
        newobj->dict = 0;
#endif
      }
    } else {
      newobj = PyObject_New(SwigPyObject, clientdata->pytype);
#ifdef SWIGPYTHON_BUILTIN
      newobj->dict = 0;
#endif
    }
    if (newobj) {
      newobj->ptr = ptr;
      newobj->ty = type;
      newobj->own = own;
      newobj->next = 0;
      return (PyObject*) newobj;
    }
    return SWIG_Py_Void();
  }

  assert(!(flags & SWIG_BUILTIN_TP_INIT));

  robj = SwigPyObject_New(ptr, type, own);
  if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
    PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
    Py_DECREF(robj);
    robj = inst;
  }
  return robj;
}

/* Create a new packed object */

SWIGRUNTIMEINLINE PyObject *
SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
  return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
}

/* -----------------------------------------------------------------------------*
 *  Get type list 
 * -----------------------------------------------------------------------------*/

#ifdef SWIG_LINK_RUNTIME
void *SWIG_ReturnGlobalTypeList(void *);
#endif

SWIGRUNTIME swig_module_info *
SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
  static void *type_pointer = (void *)0;
  /* first check if module already created */
  if (!type_pointer) {
#ifdef SWIG_LINK_RUNTIME
    type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
#else
    type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
    if (PyErr_Occurred()) {
      PyErr_Clear();
      type_pointer = (void *)0;
    }
#endif
  }
  return (swig_module_info *) type_pointer;
}

SWIGRUNTIME void
SWIG_Python_DestroyModule(PyObject *obj)
{
  swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
  swig_type_info **types = swig_module->types;
  size_t i;
  for (i =0; i < swig_module->size; ++i) {
    swig_type_info *ty = types[i];
    if (ty->owndata) {
      SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
      if (data) SwigPyClientData_Del(data);
    }
  }
  Py_DECREF(SWIG_This());
  Swig_This_global = NULL;
}

SWIGRUNTIME void
SWIG_Python_SetModule(swig_module_info *swig_module) {
#if PY_VERSION_HEX >= 0x03000000
 /* Add a dummy module object into sys.modules */
  PyObject *module = PyImport_AddModule("swig_runtime_data" SWIG_RUNTIME_VERSION);
#else
  static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
  PyObject *module = Py_InitModule("swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
#endif
  PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
  if (pointer && module) {
    PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
  } else {
    Py_XDECREF(pointer);
  }
}

/* The python cached type query */
SWIGRUNTIME PyObject *
SWIG_Python_TypeCache(void) {
  static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
  return cache;
}

SWIGRUNTIME swig_type_info *
SWIG_Python_TypeQuery(const char *type)
{
  PyObject *cache = SWIG_Python_TypeCache();
  PyObject *key = SWIG_Python_str_FromChar(type); 
  PyObject *obj = PyDict_GetItem(cache, key);
  swig_type_info *descriptor;
  if (obj) {
    descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
  } else {
    swig_module_info *swig_module = SWIG_GetModule(0);
    descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
    if (descriptor) {
      obj = PyCapsule_New((void*) descriptor, NULL, NULL);
      PyDict_SetItem(cache, key, obj);
      Py_DECREF(obj);
    }
  }
  Py_DECREF(key);
  return descriptor;
}

/* 
   For backward compatibility only
*/
#define SWIG_POINTER_EXCEPTION  0
#define SWIG_arg_fail(arg)      SWIG_Python_ArgFail(arg)
#define SWIG_MustGetPtr(p, type, argnum, flags)  SWIG_Python_MustGetPtr(p, type, argnum, flags)

SWIGRUNTIME int
SWIG_Python_AddErrMesg(const char* mesg, int infront)
{  
  if (PyErr_Occurred()) {
    PyObject *type = 0;
    PyObject *value = 0;
    PyObject *traceback = 0;
    PyErr_Fetch(&type, &value, &traceback);
    if (value) {
      PyObject *old_str = PyObject_Str(value);
      const char *tmp = SWIG_Python_str_AsChar(old_str);
      const char *errmesg = tmp ? tmp : "Invalid error message";
      Py_XINCREF(type);
      PyErr_Clear();
      if (infront) {
	PyErr_Format(type, "%s %s", mesg, errmesg);
      } else {
	PyErr_Format(type, "%s %s", errmesg, mesg);
      }
      SWIG_Python_str_DelForPy3(tmp);
      Py_DECREF(old_str);
    }
    return 1;
  } else {
    return 0;
  }
}
  
SWIGRUNTIME int
SWIG_Python_ArgFail(int argnum)
{
  if (PyErr_Occurred()) {
    /* add information about failing argument */
    char mesg[256];
    PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
    return SWIG_Python_AddErrMesg(mesg, 1);
  } else {
    return 0;
  }
}

SWIGRUNTIMEINLINE const char *
SwigPyObject_GetDesc(PyObject *self)
{
  SwigPyObject *v = (SwigPyObject *)self;
  swig_type_info *ty = v ? v->ty : 0;
  return ty ? ty->str : "";
}

SWIGRUNTIME void
SWIG_Python_TypeError(const char *type, PyObject *obj)
{
  if (type) {
#if defined(SWIG_COBJECT_TYPES)
    if (obj && SwigPyObject_Check(obj)) {
      const char *otype = (const char *) SwigPyObject_GetDesc(obj);
      if (otype) {
	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
		     type, otype);
	return;
      }
    } else 
#endif      
    {
      const char *otype = (obj ? obj->ob_type->tp_name : 0); 
      if (otype) {
	PyObject *str = PyObject_Str(obj);
	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	if (cstr) {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
		       type, otype, cstr);
          SWIG_Python_str_DelForPy3(cstr);
	} else {
	  PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
		       type, otype);
	}
	Py_XDECREF(str);
	return;
      }
    }   
    PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
  } else {
    PyErr_Format(PyExc_TypeError, "unexpected type is received");
  }
}


/* Convert a pointer value, signal an exception on a type mismatch */
SWIGRUNTIME void *
SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
  void *result;
  if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
    PyErr_Clear();
#if SWIG_POINTER_EXCEPTION
    if (flags) {
      SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
      SWIG_Python_ArgFail(argnum);
    }
#endif
  }
  return result;
}

#ifdef SWIGPYTHON_BUILTIN
SWIGRUNTIME int
SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
  PyTypeObject *tp = obj->ob_type;
  PyObject *descr;
  PyObject *encoded_name;
  descrsetfunc f;
  int res = -1;

# ifdef Py_USING_UNICODE
  if (PyString_Check(name)) {
    name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
    if (!name)
      return -1;
  } else if (!PyUnicode_Check(name))
# else
  if (!PyString_Check(name))
# endif
  {
    PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
    return -1;
  } else {
    Py_INCREF(name);
  }

  if (!tp->tp_dict) {
    if (PyType_Ready(tp) < 0)
      goto done;
  }

  descr = _PyType_Lookup(tp, name);
  f = NULL;
  if (descr != NULL)
    f = descr->ob_type->tp_descr_set;
  if (!f) {
    if (PyString_Check(name)) {
      encoded_name = name;
      Py_INCREF(name);
    } else {
      encoded_name = PyUnicode_AsUTF8String(name);
      if (!encoded_name)
        return -1;
    }
    PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
    Py_DECREF(encoded_name);
  } else {
    res = f(descr, obj, value);
  }
  
  done:
  Py_DECREF(name);
  return res;
}
#endif


#ifdef __cplusplus
}
#endif



#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 

#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 



#ifdef __cplusplus
extern "C" {
#endif

/* Method creation and docstring support functions */

SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name);
SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);
SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func);

#ifdef __cplusplus
}
#endif


/* -------- TYPES TABLE (BEGIN) -------- */

#define SWIGTYPE_p_ConstSpiceBoolean swig_types[0]
#define SWIGTYPE_p_ConstSpiceChar swig_types[1]
#define SWIGTYPE_p_ConstSpiceDouble swig_types[2]
#define SWIGTYPE_p_ConstSpiceInt swig_types[3]
#define SWIGTYPE_p_SpiceBoolean swig_types[4]
#define SWIGTYPE_p_SpiceChar swig_types[5]
#define SWIGTYPE_p_SpiceDouble swig_types[6]
#define SWIGTYPE_p_SpiceInt swig_types[7]
#define SWIGTYPE_p_a_2__ConstSpiceDouble swig_types[8]
#define SWIGTYPE_p_a_2__SpiceDouble swig_types[9]
#define SWIGTYPE_p_a_3__ConstSpiceDouble swig_types[10]
#define SWIGTYPE_p_a_3__ConstSpiceInt swig_types[11]
#define SWIGTYPE_p_a_3__SpiceDouble swig_types[12]
#define SWIGTYPE_p_a_3__SpiceInt swig_types[13]
#define SWIGTYPE_p_a_4__ConstSpiceDouble swig_types[14]
#define SWIGTYPE_p_a_6__ConstSpiceDouble swig_types[15]
#define SWIGTYPE_p_a_6__SpiceDouble swig_types[16]
#define SWIGTYPE_p_a_COLLEN__char swig_types[17]
#define SWIGTYPE_p_a_COMMENTLEN__char swig_types[18]
#define SWIGTYPE_p_a_KERVALLEN__char swig_types[19]
#define SWIGTYPE_p_a_NAMELEN__SpiceChar swig_types[20]
#define SWIGTYPE_p_a_NAMELEN__char swig_types[21]
#define SWIGTYPE_p_char swig_types[22]
#define SWIGTYPE_p_int swig_types[23]
#define SWIGTYPE_p_p_SpiceBoolean swig_types[24]
#define SWIGTYPE_p_p_SpiceDouble swig_types[25]
#define SWIGTYPE_p_p_SpiceInt swig_types[26]
static swig_type_info *swig_types[28];
static swig_module_info swig_module = {swig_types, 27, 0, 0, 0, 0};
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)

/* -------- TYPES TABLE (END) -------- */

#ifdef SWIG_TypeQuery
# undef SWIG_TypeQuery
#endif
#define SWIG_TypeQuery SWIG_Python_TypeQuery

/*-----------------------------------------------
              @(target):= _cspyce0.so
  ------------------------------------------------*/
#if PY_VERSION_HEX >= 0x03000000
#  define SWIG_init    PyInit__cspyce0

#else
#  define SWIG_init    init_cspyce0

#endif
#define SWIG_name    "_cspyce0"

#define SWIGVERSION 0x040001 
#define SWIG_VERSION SWIGVERSION


#define SWIG_as_voidptr(a) (void *)((const void *)(a)) 
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) 


#define SWIG_FILE_WITH_INIT

#include "SpiceUsr.h"
#include "SpiceCel.h"
#include "SpiceOsc.h"
#include <math.h>
#include <stdio.h>

#define NPLANE 4
#define NELLIPSE 9
#define DAFSIZE 256     // DAF size
#define DASSIZE 256     // DAS size
#define DLASIZE 8
#define DSKSIZE 42

#define CLAUSES 100     // max number of expressions in a SELECT clause
#define COLLEN 100      // max length of string columns or parsed items
#define COMMENTLEN 100  // max length of a comment including null
#define COMMENTS 200    // max number of comments
#define FILELEN 1000    // max length of a file path including null
#define FOVSHAPE 40     // max number of vertices in the shape of an FOV
#define KERVALLEN 80    // max length of a kernel string value
#define KERVALS 40      // max number of values associated with a kernel name
#define LONGMSGLEN 10000// max length of a long error message including null
#define MAXIDS 200      // max body or frame IDs returned
#define MAXRECS 1000    // max number of records returned in a DAS read
#define MAXROWS 1000    // max number of records/rows returned in an EK query
#define MAXVALS 100     // max number of values in a column or parsed string
#define MAXFOV 100      // max number of vertices in a FOV
#define MESSAGELEN 1024 // max length of an error message including null
#define NAMELEN 65      // table names can be 64 plus one null
#define NPLATES 10000   // max number of DSK plates or vertices
#define TIMELEN 60      // max length of a time string including null
#define WINDOWS 2000    // max time windows returned

/* Define NAN for Microsoft C compiler if necessary */
#ifdef _MSC_VER
#define INFINITY (DBL_MAX+DBL_MAX)
#define NAN (INFINITY-INFINITY)
#endif

/* Internal routine to malloc a vector of doubles */
SpiceDouble *my_malloc(int count, const char *fname) {
    SpiceDouble *result = (SpiceDouble *) PyMem_Malloc(count * sizeof(SpiceDouble));
    if (!result) {
        chkin_c(fname);
        setmsg_c("Failed to allocate memory");
        sigerr_c("SPICE(MALLOCFAILURE)");
        chkout_c(fname);
    }

    return result;
}

SpiceInt *my_int_malloc(int count, const char *fname) {
    SpiceInt *result = (SpiceInt *) PyMem_Malloc(count * sizeof(SpiceInt));
    if (!result) {
        chkin_c(fname);
        setmsg_c("Failed to allocate memory");
        sigerr_c("SPICE(MALLOCFAILURE)");
        chkout_c(fname);
    }

    return result;
}

SpiceInt *my_bool_malloc(int count, const char *fname) {
    SpiceInt *result = (SpiceInt *) PyMem_Malloc(count * sizeof(SpiceBoolean));
    if (!result) {
        chkin_c(fname);
        setmsg_c("Failed to allocate memory");
        sigerr_c("SPICE(MALLOCFAILURE)");
        chkout_c(fname);
    }

    return result;
}

SpiceChar *my_char_malloc(int count, const char *fname) {
    SpiceChar *result = (SpiceChar *) PyMem_Malloc(count * sizeof(SpiceChar));
    if (!result) {
        chkin_c(fname);
        setmsg_c("Failed to allocate memory");
        sigerr_c("SPICE(MALLOCFAILURE)");
        chkout_c(fname);
    }

    return result;
}

/* Internal routine to compare integers for equality */
int my_assert_eq(int a, int b, const char *fname, const char *message) {

    if (a != b) {
        chkin_c(fname);
        setmsg_c(message);
        errint_c("#", a);
        errint_c("#", b);
        sigerr_c("SPICE(ARRAYSHAPEMISMATCH)");
        chkout_c(fname);
        return 0;
    }
    return 1;
}

/* Internal routine to compare integers for "greater than or equal to" */
int my_assert_ge(int a, int b, const char *fname, const char *message) {

    if (a < b) {
        chkin_c(fname);
        setmsg_c(message);
        errint_c("#", a);
        errint_c("#", b);
        sigerr_c("SPICE(ARRAYSHAPEMISMATCH)");
        chkout_c(fname);
        return 0;
    }
    return 1;
}

// Prototypes
void frmchg_(SpiceInt    *frame1,
             SpiceInt    *frame2,
             SpiceDouble *et,
             SpiceDouble *xform);

void refchg_(SpiceInt    *frame1,
             SpiceInt    *frame2,
             SpiceDouble *et,
             SpiceDouble *rotate);

int stcf01_(ConstSpiceChar *catnam,
            SpiceDouble    *westra,
            SpiceDouble    *eastra,
            SpiceDouble    *sthdec,
            SpiceDouble    *nthdec,
            SpiceInt       *nstars,
            int            catnam_len);

int stcg01_(SpiceInt    *index,
            SpiceDouble *ra,
            SpiceDouble *dec,
            SpiceDouble *rasig,
            SpiceDouble *decsig,
            SpiceInt    *catnum,
            SpiceChar   *sptype,
            SpiceDouble *vmag,
            int         sptype_len);

int stcl01_(ConstSpiceChar *catfnm,
            SpiceChar      *tabnam,
            SpiceInt       *handle,
            int            catfnm_len,
            int            tabnam_len);

void stlabx_(ConstSpiceDouble pobj[3],
             ConstSpiceDouble vobs[3],
             SpiceDouble      corpos[3]);

// From cspyce_typemaps.i
void set_python_exception_flag(int flag);
int get_python_exception_flag(void);
char *get_message_after_reset(int option);
void reset_messages(void);



#ifndef SWIG_FILE_WITH_INIT
#define NO_IMPORT_ARRAY
#endif
#define PY_SSIZE_T_CLEAN
#include <Python.h>
#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
#include <numpy/arrayobject.h>


#ifndef SWIG_FILE_WITH_INIT
#  define NO_IMPORT_ARRAY
#endif
#include "stdio.h"
#include "stdlib.h"
#include <numpy/arrayobject.h>

#define max(a, b) ((a) > (b) ? (a) : (b))

#if PY_VERSION_HEX >= 0x03000000
#    define is_python_3xx 1
#else
#    define is_python_3xx 0
#endif

/*******************************************************************************
*******************************************************************************/

// Global variables
int USE_RUNTIME_ERRORS = 0;  //0 for default exceptions; 1 for RuntimeError only
char SHORT_MESSAGE[ 100] = "";
char LONG_MESSAGE[10000] = "";
char EXPLANATION[ 10000] = "";
char EXCEPTION_MESSAGE[10000] = "";

// flag = 0 uses meaningful exception; flag = 1 uses RuntimeErrors under most
// circumstances.
void set_python_exception_flag(int flag) {
    USE_RUNTIME_ERRORS = flag;
}

int get_python_exception_flag(void) {
    return USE_RUNTIME_ERRORS;
}

char *get_message_after_reset(int option) {
    switch (option) {
        case 0: return SHORT_MESSAGE;
        case 1: return LONG_MESSAGE;
        case 2: return EXPLANATION;
        default: return "";
    }
}

void reset_messages(void) {
    SHORT_MESSAGE[0] = '\0';
    LONG_MESSAGE[0]  = '\0';
    EXPLANATION[0]   = '\0';
}

void flush_traceback(void) {
    // Empty the traceback list
    int depth;
    trcdep_c(&depth);
    for (int k = depth-1; k >= 0; k--) {
        char module[100];
        trcnam_c(k, 100, module);
        chkout_c(module);
    }
}

void flush_traceback_to(char *name) {
    int depth;
    trcdep_c(&depth);
    for (int k = depth-1; k >= 0; k--) {
        char module[100];
        trcnam_c(k, 100, module);
        chkout_c(module);
        if (strcmp(module, name) == 0) return;
    }
}

void pop_traceback(void) {
    int depth;
    trcdep_c(&depth);
    if (depth) {
        char module[100];
        trcnam_c(depth-1, 100, module);
        chkout_c(module);
    }
}

typedef enum {
    IOError = 0,
    MemoryError = 1,
    TypeError = 2,
    KeyError = 3,
    IndexError = 4,
    ZeroDivisionError = 5,
    RuntimeError = 6,
    ValueError = 7,
    Exception_COUNT = 8,
} Exception;

// A table to convert from error codes to the corresponding Python exception
// objects.  Unfortunately, this table has to be built at start.

PyObject* errcode_to_PyErrorType[Exception_COUNT];

struct ExceptionTableEntry{
    const char* message;
    Exception exception;
};

static struct ExceptionTableEntry all_exception_table_entries[] = {
     {"SPICE(ARRAYSHAPEMISMATCH)",   ValueError},
     {"SPICE(ARRAYTOOSMALL)",        MemoryError},
     {"SPICE(BADACTION)",            ValueError},
     {"SPICE(BADARCHTYPE)",          IOError},
     {"SPICE(BADARRAYSIZE)",         MemoryError},
     {"SPICE(BADATTRIBUTES)",        IOError},
     {"SPICE(BADAXISLENGTH)",        ValueError},
     {"SPICE(BADAXISNUMBERS)",       ValueError},
     {"SPICE(BADBORESIGHTSPEC)",     ValueError},
     {"SPICE(BADBOUNDARY)",          ValueError},
     {"SPICE(BADCOARSEVOXSCALE)",    ValueError},
     {"SPICE(BADCOMMENTAREA)",       IOError},
     {"SPICE(BADCOORDSYSTEM)",       IOError},
     {"SPICE(BADDASCOMMENTAREA)",    IOError},
     {"SPICE(BADDEFAULTVALUE)",      ValueError},
     {"SPICE(BADDESCRTIMES)",        ValueError},
     {"SPICE(BADDIRECTION)",         ValueError},
     {"SPICE(BADECCENTRICITY)",      ValueError},
     {"SPICE(BADENDPOINTS)",         ValueError},
     {"SPICE(BADFILETYPE)",          IOError},
     {"SPICE(BADFINEVOXELSCALE)",    ValueError},
     {"SPICE(BADFRAME)",             ValueError},
     {"SPICE(BADFRAMECLASS)",        ValueError},
     {"SPICE(BADGM)",                ValueError},
     {"SPICE(BADINDEX)",             ValueError},
     {"SPICE(BADINITSTATE)",         RuntimeError},
     {"SPICE(BADLATUSRECTUM)",       ValueError},
     {"SPICE(BADLIMBLOCUSMIX)",      ValueError},
     {"SPICE(BADPARTNUMBER)",        ValueError},
     {"SPICE(BADPERIAPSEVALUE)",     ValueError},
     {"SPICE(BADPLATECOUNT)",        ValueError},
     {"SPICE(BADRADIUS)",            ValueError},
     {"SPICE(BADRADIUSCOUNT)",       ValueError},
     {"SPICE(BADREFVECTORSPEC)",     ValueError},
     {"SPICE(BADSEMIAXIS)",          ValueError},
     {"SPICE(BADSTOPTIME)",          ValueError},
     {"SPICE(BADTIMEITEM)",          ValueError},
     {"SPICE(BADTIMESTRING)",        ValueError},
     {"SPICE(BADTIMETYPE)",          ValueError},
     {"SPICE(BADVARIABLESIZE)",      ValueError},
     {"SPICE(BADVARIABLETYPE)",      TypeError},
     {"SPICE(BADVARNAME)",           IOError},
     {"SPICE(BADVECTOR)",            ValueError},
     {"SPICE(BADVERTEXCOUNT)",       ValueError},
     {"SPICE(BADVERTEXINDEX)",       IndexError},
     {"SPICE(BARYCENTEREPHEM)",      ValueError},
     {"SPICE(BLANKFILENAME)",        IOError},
     {"SPICE(BLANKMODULENAME)",      ValueError},
     {"SPICE(BODIESNOTDISTINCT)",    ValueError},
     {"SPICE(BODYANDCENTERSAME)",    ValueError},
     {"SPICE(BODYIDNOTFOUND)",       KeyError},
     {"SPICE(BODYNAMENOTFOUND)",     KeyError},
     {"SPICE(BORESIGHTMISSING)",     ValueError},
     {"SPICE(BOUNDARYMISSING)",      ValueError},
     {"SPICE(BOUNDARYTOOBIG)",       MemoryError},
     {"SPICE(BOUNDSOUTOFORDER)",     ValueError},
     {"SPICE(BUFFEROVERFLOW)",       MemoryError},
     {"SPICE(BUG)",                  RuntimeError},
     {"SPICE(CANTFINDFRAME)",        KeyError},
     {"SPICE(CELLTOOSMALL)",         MemoryError},
     {"SPICE(CKINSUFFDATA)",         IOError},
     {"SPICE(CKTOOMANYFILES)",       MemoryError},
     {"SPICE(COLUMNTOOSMALL)",       MemoryError},
     {"SPICE(COMMENTTOOLONG)",       MemoryError},
     {"SPICE(COORDSYSNOTREC)",       ValueError},
     {"SPICE(COVERAGEGAP)",          IOError},
     {"SPICE(CROSSANGLEMISSING)",    ValueError},
     {"SPICE(DAFBEGGTEND)",          IOError},
     {"SPICE(DAFFRNOTFOUND)",        IOError},
     {"SPICE(DAFFTFULL)",            MemoryError},
     {"SPICE(DAFIMPROPOPEN)",        IOError},
     {"SPICE(DAFNEGADDR)",           IOError},
     {"SPICE(DAFNOSEARCH)",          IOError},
     {"SPICE(DAFOPENFAIL)",          IOError},
     {"SPICE(DAFRWCONFLICT)",        IOError},
     {"SPICE(DASFILEREADFAILED)",    IOError},
     {"SPICE(DASFTFULL)",            MemoryError},
     {"SPICE(DASIMPROPOPEN)",        IOError},
     {"SPICE(DASNOSUCHHANDLE)",      IOError},
     {"SPICE(DASOPENCONFLICT)",      IOError},
     {"SPICE(DASOPENFAIL)",          IOError},
     {"SPICE(DASRWCONFLICT)",        IOError},
     {"SPICE(DEGENERATECASE)",       ValueError},
     {"SPICE(DEGENERATEINTERVAL)",   ValueError},
     {"SPICE(DEGENERATESURFACE)",    ValueError},
     {"SPICE(DEPENDENTVECTORS)",     ValueError},
     {"SPICE(DEVICENAMETOOLONG)",    MemoryError},
     {"SPICE(DIVIDEBYZERO)",         ZeroDivisionError},
     {"SPICE(DSKTARGETMISMATCH)",    ValueError},
     {"SPICE(DTOUTOFRANGE)",         ValueError},
     {"SPICE(DUBIOUSMETHOD)",        ValueError},
     {"SPICE(ECCOUTOFRANGE)",        ValueError},
     {"SPICE(EKCOLATTRTABLEFULL)",   MemoryError},
     {"SPICE(EKCOLDESCTABLEFULL)",   MemoryError},
     {"SPICE(EKFILETABLEFULL)",      MemoryError},
     {"SPICE(EKIDTABLEFULL)",        MemoryError},
     {"SPICE(EKNOSEGMENTS)",         IOError},
     {"SPICE(EKSEGMENTTABLEFULL)",   MemoryError},
     {"SPICE(ELEMENTSTOOSHORT)",     ValueError},
     {"SPICE(EMPTYSEGMENT)",         ValueError},
     {"SPICE(EMPTYSTRING)",          ValueError},
     {"SPICE(FILECURRENTLYOPEN)",    IOError},
     {"SPICE(FILEDOESNOTEXIST)",     IOError},
     {"SPICE(FILEISNOTSPK)",         IOError},
     {"SPICE(FILENOTFOUND)",         IOError},
     {"SPICE(FILEOPENFAILED)",       IOError},
     {"SPICE(FILEREADFAILED)",       IOError},
     {"SPICE(FRAMEIDNOTFOUND)",      KeyError},
     {"SPICE(FRAMEMISSING)",         ValueError},
     {"SPICE(FRAMENAMENOTFOUND)",    KeyError},
     {"SPICE(GRIDTOOLARGE)",         MemoryError},
     {"SPICE(IDCODENOTFOUND)",       KeyError},
     {"SPICE(ILLEGALCHARACTER)",     ValueError},
     {"SPICE(IMMUTABLEVALUE)",       RuntimeError},
     {"SPICE(INCOMPATIBLESCALE)",    ValueError},
     {"SPICE(INCOMPATIBLEUNITS)",    ValueError},
     {"SPICE(INDEXOUTOFRANGE)",      IndexError},
     {"SPICE(INPUTOUTOFRANGE)",      ValueError},
     {"SPICE(INPUTSTOOLARGE)",       ValueError},
     {"SPICE(INQUIREERROR)",         IOError},
     {"SPICE(INQUIREFAILED)",        IOError},
     {"SPICE(INSUFFICIENTANGLES)",   ValueError},
     {"SPICE(INSUFFLEN)",            MemoryError},
     {"SPICE(INTINDEXTOOSMALL)",     ValueError},
     {"SPICE(INTLENNOTPOS)",         ValueError},
     {"SPICE(INTOUTOFRANGE)",        ValueError},
     {"SPICE(INVALDINDEX)",          IndexError},
     {"SPICE(INVALIDACTION)",        ValueError},
     {"SPICE(INVALIDARCHTYPE)",      IOError},
     {"SPICE(INVALIDARGUMENT)",      ValueError},
     {"SPICE(INVALIDARRAYRANK)",     ValueError},
     {"SPICE(INVALIDARRAYSHAPE)",    ValueError},
     {"SPICE(INVALIDARRAYTYPE)",     ValueError},
     {"SPICE(INVALIDAXISLENGTH)",    ValueError},
     {"SPICE(INVALIDCARDINALITY)",   ValueError},
     {"SPICE(INVALIDCOUNT)",         ValueError},
     {"SPICE(INVALIDDEGREE)",        ValueError},
     {"SPICE(INVALIDDESCRTIME)",     ValueError},
     {"SPICE(INVALIDDIMENSION)",     ValueError},
     {"SPICE(INVALIDELLIPSE)",       ValueError},
     {"SPICE(INVALIDENDPNTSPEC)",    ValueError},
     {"SPICE(INVALIDEPOCH)",         ValueError},
     {"SPICE(INVALIDFORMAT)",        ValueError},
     {"SPICE(INVALIDFRAME)",         ValueError},
     {"SPICE(INVALIDFRAMEDEF)",      ValueError},
     {"SPICE(INVALIDINDEX)",         IndexError},
     {"SPICE(INVALIDLIMBTYPE)",      ValueError},
     {"SPICE(INVALIDLISTITEM)",      ValueError},
     {"SPICE(INVALIDLOCUS)",         ValueError},
     {"SPICE(INVALIDLONEXTENT)",     ValueError},
     {"SPICE(INVALIDMETHOD)",        ValueError},
     {"SPICE(INVALIDMSGTYPE)",       ValueError},
     {"SPICE(INVALIDNUMINTS)",       ValueError},
     {"SPICE(INVALIDNUMRECS)",       ValueError},
     {"SPICE(INVALIDOCCTYPE)",       ValueError},
     {"SPICE(INVALIDOPERATION)",     ValueError},
     {"SPICE(INVALIDOPTION)",        ValueError},
     {"SPICE(INVALIDPLANE)",         ValueError},
     {"SPICE(INVALIDPOINT)",         ValueError},
     {"SPICE(INVALIDRADIUS)",        ValueError},
     {"SPICE(INVALIDREFFRAME)",      ValueError},
     {"SPICE(INVALIDROLLSTEP)",      ValueError},
     {"SPICE(INVALIDSCLKSTRING)",    ValueError},
     {"SPICE(INVALIDSCLKTIME)",      ValueError},
     {"SPICE(INVALIDSEARCHSTEP)",    ValueError},
     {"SPICE(INVALIDSIGNAL)",        RuntimeError},
     {"SPICE(INVALIDSIZE)",          ValueError},
     {"SPICE(INVALIDSTARTTIME)",     ValueError},
     {"SPICE(INVALIDSTATE)",         ValueError},
     {"SPICE(INVALIDSTEP)",          ValueError},
     {"SPICE(INVALIDSTEPSIZE)",      ValueError},
     {"SPICE(INVALIDSUBTYPE)",       ValueError},
     {"SPICE(INVALIDTARGET)",        ValueError},
     {"SPICE(INVALIDTERMTYPE)",      ValueError},
     {"SPICE(INVALIDTIMEFORMAT)",    ValueError},
     {"SPICE(INVALIDTIMESTRING)",    ValueError},
     {"SPICE(INVALIDTOL)",           ValueError},
     {"SPICE(INVALIDTOLERANCE)",     ValueError},
     {"SPICE(INVALIDTYPE)",          TypeError},
     {"SPICE(INVALIDVALUE)",         ValueError},
     {"SPICE(INVALIDVERTEX)",        ValueError},
     {"SPICE(KERNELPOOLFULL)",       MemoryError},
     {"SPICE(KERNELVARNOTFOUND)",    KeyError},
     {"SPICE(MALLOCFAILED)",         MemoryError},
     {"SPICE(MALLOCFAILURE)",        MemoryError},
     {"SPICE(MEMALLOCFAILED)",       MemoryError},
     {"SPICE(MESSAGETOOLONG)",       MemoryError},
     {"SPICE(MISSINGDATA)",          ValueError},
     {"SPICE(MISSINGTIMEINFO)",      ValueError},
     {"SPICE(MISSINGVALUE)",         ValueError},
     {"SPICE(NAMESDONOTMATCH)",      ValueError},
     {"SPICE(NOCLASS)",              ValueError},
     {"SPICE(NOCOLUMN)",             ValueError},
     {"SPICE(NOCURRENTARRAY)",       IOError},
     {"SPICE(NOFRAME)",              ValueError},
     {"SPICE(NOFRAMEINFO)",          ValueError},
     {"SPICE(NOINTERCEPT)",          ValueError},
     {"SPICE(NOINTERVAL)",           ValueError},
     {"SPICE(NOLOADEDFILES)",        IOError},
     {"SPICE(NOMOREROOM)",           MemoryError},
     {"SPICE(NONCONICMOTION)",       ValueError},
     {"SPICE(NONCONTIGUOUSARRAY)",   ValueError},
     {"SPICE(NONPOSITIVEMASS)",      ValueError},
     {"SPICE(NONPOSITIVESCALE)",     ValueError},
     {"SPICE(NONPRINTABLECHARS)",    ValueError},
     {"SPICE(NOPARTITION)",          ValueError},
     {"SPICE(NOPATHVALUE)",          ValueError},
     {"SPICE(NOPRIORITIZATION)",     ValueError},
     {"SPICE(NOSEGMENTSFOUND)",      IOError},
     {"SPICE(NOSEPARATION)",         ValueError},
     {"SPICE(NOSUCHFILE)",           IOError},
     {"SPICE(NOTADAFFILE)",          IOError},
     {"SPICE(NOTADASFILE)",          IOError},
     {"SPICE(NOTADPNUMBER)",         ValueError},
     {"SPICE(NOTANINTEGER)",         ValueError},
     {"SPICE(NOTAROTATION)",         ValueError},
     {"SPICE(NOTASET)",              TypeError},
     {"SPICE(NOTINITIALIZED)",       RuntimeError},
     {"SPICE(NOTINPART)",            ValueError},
     {"SPICE(NOTPRINTABLECHARS)",    ValueError},
     {"SPICE(NOTRANSLATION)",        KeyError},
     {"SPICE(NOTRECOGNIZED)",        ValueError},
     {"SPICE(NOTSUPPORTED)",         ValueError},
     {"SPICE(NULLPOINTER)",          ValueError},
     {"SPICE(NUMCOEFFSNOTPOS)",      ValueError},
     {"SPICE(NUMERICOVERFLOW)",      ValueError},
     {"SPICE(NUMPARTSUNEQUAL)",      ValueError},
     {"SPICE(NUMSTATESNOTPOS)",      ValueError},
     {"SPICE(OUTOFROOM)",            MemoryError},
     {"SPICE(PCKFILETABLEFULL)",     MemoryError},
     {"SPICE(PLATELISTTOOSMALL)",    ValueError},
     {"SPICE(POINTNOTONSURFACE)",    ValueError},
     {"SPICE(POINTONZAXIS)",         ValueError},
     {"SPICE(PTRARRAYTOOSMALL)",     ValueError},
     {"SPICE(RECURSIVELOADING)",     IOError},
     {"SPICE(REFANGLEMISSING)",      ValueError},
     {"SPICE(REFVECTORMISSING)",     ValueError},
     {"SPICE(SCLKTRUNCATED)",        ValueError},
     {"SPICE(SEGIDTOOLONG)",         ValueError},
     {"SPICE(SETEXCESS)",            MemoryError},
     {"SPICE(SHAPEMISSING)",         ValueError},
     {"SPICE(SHAPENOTSUPPORTED)",    ValueError},
     {"SPICE(SIGNALFAILED)",         RuntimeError},
     {"SPICE(SIGNALFAILURE)",        RuntimeError},
     {"SPICE(SINGULARMATRIX)",       ValueError},
     {"SPICE(SPKFILETABLEFULL)",     MemoryError},
     {"SPICE(SPKINSUFFDATA)",        IOError},
     {"SPICE(SPKINVALIDOPTION)",     IOError},
     {"SPICE(SPKNOTASUBSET)",        IOError},
     {"SPICE(SPKTYPENOTSUPP)",       IOError},
     {"SPICE(STRINGTOOLSHORT)",      ValueError},
     {"SPICE(STRINGTOOSHORT)",       ValueError},
     {"SPICE(SUBPOINTNOTFOUND)",     ValueError},
     {"SPICE(TABLENOTLOADED)",       IOError},
     {"SPICE(TARGETMISMATCH)",       ValueError},
     {"SPICE(TIMECONFLICT)",         ValueError},
     {"SPICE(TIMESDONTMATCH)",       ValueError},
     {"SPICE(TIMESOUTOFORDER)",      ValueError},
     {"SPICE(TOOFEWPACKETS)",        ValueError},
     {"SPICE(TOOFEWPLATES)",         ValueError},
     {"SPICE(TOOFEWSTATES)",         ValueError},
     {"SPICE(TOOFEWVERTICES)",       ValueError},
     {"SPICE(TOOMANYFILESOPEN)",     IOError},
     {"SPICE(TOOMANYPARTS)",         ValueError},
     {"SPICE(TRACEBACKOVERFLOW)",    MemoryError},
     {"SPICE(TRACESTACKEMPTY)",      RuntimeError},
     {"SPICE(TYPEMISMATCH)",         TypeError},
     {"SPICE(UNDEFINEDFRAME)",       ValueError},
     {"SPICE(UNITSMISSING)",         ValueError},
     {"SPICE(UNITSNOTREC)",          ValueError},
     {"SPICE(UNKNOWNCOMPARE)",       ValueError},
     {"SPICE(UNKNOWNFRAME)",         KeyError},
     {"SPICE(UNKNOWNSPKTYPE)",       IOError},
     {"SPICE(UNKNOWNSYSTEM)",        ValueError},
     {"SPICE(UNMATCHENDPTS)",        ValueError},
     {"SPICE(UNORDEREDTIMES)",       ValueError},
     {"SPICE(UNPARSEDTIME)",         ValueError},
     {"SPICE(UNSUPPORTEDBFF)",       IOError},
     {"SPICE(UNSUPPORTEDSPEC)",      IOError},
     {"SPICE(VALUEOUTOFRANGE)",      ValueError},
     {"SPICE(VARIABLENOTFOUND)",     KeyError},
     {"SPICE(VECTORTOOBIG)",         ValueError},
     {"SPICE(WINDOWEXCESS)",         MemoryError},
     {"SPICE(WINDOWTOOSMALL)",       ValueError},
     {"SPICE(WORKSPACETOOSMALL)",    MemoryError},
     {"SPICE(WRONGDATATYPE)",        TypeError},
     {"SPICE(YEAROUTOFRANGE)",       ValueError},
     {"SPICE(ZEROBOUNDSEXTENT)",     ValueError},
     {"SPICE(ZEROLENGTHCOLUMN)",     ValueError},
     {"SPICE(ZEROPOSITION)",         ValueError},
     {"SPICE(ZEROQUATERNION)",       ValueError},
     {"SPICE(ZEROVECTOR)",           ValueError},
     {"SPICE(ZEROVELOCITY)",         ValueError},
};

static int exception_compare_function(const void* pkey, const void* pelem) {
    const char* key = pkey;
    const struct ExceptionTableEntry *entry = pelem;
    return strcmp(key, entry->message);
}

Exception select_exception(char *shortmsg) {
    // RuntimeErrors only
    if (USE_RUNTIME_ERRORS) {
        return RuntimeError;
    }
    int element_size = sizeof(all_exception_table_entries[0]);
    int elements = sizeof(all_exception_table_entries) / element_size;
    struct ExceptionTableEntry *result =
        bsearch(shortmsg, all_exception_table_entries, elements, element_size,
        exception_compare_function);
    return result ? result->exception : RuntimeError;
}

char *get_exception_message(const char *name) {
    // Save the messages globally
    getmsg_c("SHORT",     100, SHORT_MESSAGE);
    getmsg_c("LONG",    10000, LONG_MESSAGE );
    getmsg_c("EXPLAIN", 10000, EXPLANATION  );

    // Create the exception message
    getmsg_c("SHORT", 100, EXCEPTION_MESSAGE);
    strcat(EXCEPTION_MESSAGE, " -- ");
    if (name[0]) {
        strcat(EXCEPTION_MESSAGE, name);
        strcat(EXCEPTION_MESSAGE, " -- ");
    }
    strcat(EXCEPTION_MESSAGE, LONG_MESSAGE);

    return EXCEPTION_MESSAGE;
}

void set_python_exception(const char *symname) {
    char *message = get_exception_message(symname);
    Exception errtype = select_exception(SHORT_MESSAGE);
    PyObject* exception = errcode_to_PyErrorType[errtype];
    PyErr_SetString(exception, message);
}

void initialize_typemap_globals(void) {
    errcode_to_PyErrorType[IOError] = PyExc_IOError;
    errcode_to_PyErrorType[MemoryError] = PyExc_MemoryError;
    errcode_to_PyErrorType[TypeError] = PyExc_TypeError;
    errcode_to_PyErrorType[KeyError] = PyExc_KeyError;
    errcode_to_PyErrorType[IndexError] = PyExc_IndexError;
    errcode_to_PyErrorType[ZeroDivisionError] = PyExc_ZeroDivisionError;
    errcode_to_PyErrorType[RuntimeError] = PyExc_RuntimeError;
    errcode_to_PyErrorType[ValueError] = PyExc_ValueError;
}


void handle_swig_exception(const char *symname) {
    chkin_c(symname);
    set_python_exception(symname);
    chkout_c(symname);
    reset_c();
}


void handle_sigerr_exception(void) {
    // TODO(fy): Ask Mark why we can't use $symname
    int depth;
    char symname[100];

    trcdep_c(&depth);
    if (depth > 0) {
        trcnam_c(depth-1, 100, symname);
    } else {
        symname[0] = 0;
    }

    set_python_exception(symname);
    pop_traceback();
    reset_c();
}


void handle_malloc_failure(const char* symname) {
    chkin_c(symname);
    setmsg_c("Failed to allocate memory");
    sigerr_c("SPICE(MALLOCFAILURE)");
    chkout_c(symname);
    PyErr_SetString(USE_RUNTIME_ERRORS ? PyExc_MemoryError : PyExc_RuntimeError,
                    get_exception_message(symname));
    reset_c();
}


void handle_bad_string_error(const char* symname) {
    chkin_c(symname);
    setmsg_c("Expected String");
    sigerr_c("SPICE(INVALIDARGUMENT)");
    chkout_c(symname);
    PyErr_SetString(
        USE_RUNTIME_ERRORS ? PyExc_ValueError : PyExc_RuntimeError,
        get_exception_message(symname));
    reset_c();
}


void handle_invalid_array_shape_1d(const char *symname, PyArrayObject *pyarr, int required) {
    chkin_c(symname);
    setmsg_c("Invalid array shape (#) in module #; (#) is required");
    errint_c("#", (int) PyArray_DIM(pyarr, 0));
    errch_c( "#", symname);
    errint_c("#", (int) (required));
    sigerr_c("SPICE(INVALID_ARRAY_SHAPE)");
    chkout_c(symname);

    PyErr_SetString(
        USE_RUNTIME_ERRORS ? PyExc_ValueError : PyExc_RuntimeError,
        get_exception_message(symname));
    reset_c();
}


void handle_invalid_array_shape_2d(const char *symname, PyArrayObject *pyarr, int req0, int req1) {
    chkin_c(symname);
    setmsg_c("Invalid array shape (#,#) in module #; (#,#) is required");
    errint_c("#", (int) PyArray_DIM(pyarr, 0));
    errint_c("#", (int) PyArray_DIM(pyarr, 1));
    errch_c( "#", symname);
    errint_c("#", req0);
    errint_c("#", req1);
    sigerr_c("SPICE(INVALID_ARRAY_SHAPE)");
    chkout_c(symname);

    PyErr_SetString(
        USE_RUNTIME_ERRORS ? PyExc_ValueError : PyExc_RuntimeError,
        get_exception_message(symname));
    reset_c();
}


void handle_invalid_array_shape_x2d(const char *symname, PyArrayObject *pyarr, int req1) {
    chkin_c(symname);
    setmsg_c("Invalid array shape (#,#) in module #; (*,#) is required");
    errint_c("#", (int) PyArray_DIM(pyarr, 0));
    errint_c("#", (int) PyArray_DIM(pyarr, 1));
    errch_c( "#", symname);
    errint_c("#", req1);
    sigerr_c("SPICE(INVALID_ARRAY_SHAPE)");
    chkout_c(symname);

    PyErr_SetString(
        USE_RUNTIME_ERRORS ? PyExc_ValueError : PyExc_RuntimeError,
        get_exception_message(symname));
    reset_c();
}


extern const char* typecode_string(int typecode);

void handle_bad_array_conversion(const char* symname, int typecode, PyObject *input, int min, int max) {
    if (!input || !PyArray_Check(input)) {
        setmsg_c("Array of type \"#\" required in module #; "
                 "input argument could not be converted");
        errch_c("#", typecode_string(typecode));
        errch_c("#", symname);
        sigerr_c("SPICE(INVALIDTYPE)");
    } else if (PyArray_NDIM(input) < min || PyArray_NDIM(input) > max) {
        if (min == max) {
            setmsg_c("Invalid array rank # in module #; # is required");
        } else {
            setmsg_c("Invalid array rank # in module #; # or # is required");
        }
        errint_c("#", (int) PyArray_NDIM(input));
        errch_c( "#", symname);
        errint_c("#", (int) (min));
        if (min != max) {
            errint_c("#", (int) (max));
        }
        sigerr_c("SPICE(INVALID_ARRAY_RANK)");
        PyErr_SetString(
            USE_RUNTIME_ERRORS ? PyExc_ValueError : PyExc_RuntimeError,
            get_exception_message(symname));
        reset_c();
        return;
    } else {
        setmsg_c("Array of type \"#\" required in module #; "
                 "array of type \"#\" could not be converted");
        errch_c("#", typecode_string(typecode));
        errch_c("#", symname);
        errch_c("#", typecode_string(PyArray_TYPE(input)));
        sigerr_c("SPICE(INVALIDARRAYTYPE)");
    }
    // We don't like the error that's already been set up by the array conversion code
    // so we modify it to be what we want.
    set_python_exception(symname);
    reset_c();
}


void handle_bad_sequence_to_list(const char *symname) {
    chkin_c(symname);
    setmsg_c("Input argument must be a sequence in module #");
    errch_c( "#", symname);
    sigerr_c("SPICE(INVALIDTYPE)");
    chkout_c(symname);
    PyErr_SetString(
        USE_RUNTIME_ERRORS ? PyExc_TypeError : PyExc_RuntimeError,
        get_exception_message(symname));
    reset_c();
}


void resize_char_array_to_minimum_size(
        char **buffer, size_t* size, size_t needed_size, int* alloc) {
    if (needed_size <= 0) {
        needed_size = 1;
    }
    if (*size >= needed_size) {
        // do nothing
    } else if (SWIG_IsNewObj(*alloc)) {
        *buffer = PyMem_Realloc(*buffer, needed_size + 1);
        *size = needed_size;
    } else {
        void *original = *buffer;
        *buffer = PyMem_Malloc(needed_size + 1);
        if (*buffer) {
            strncpy(*buffer, original, *size + 1);
            *size = needed_size;
            *alloc = SWIG_NEWOBJ;
        }
    }
}



#if NPY_API_VERSION < 0x00000007
#define NPY_ARRAY_DEFAULT NPY_DEFAULT
#define NPY_ARRAY_FARRAY  NPY_FARRAY
#define NPY_FORTRANORDER  NPY_FORTRAN
#endif


/* Macros to extract array attributes.
 */
#if NPY_API_VERSION < 0x00000007
#define is_array(a)            ((a) && PyArray_Check((PyArrayObject*)a))
#define array_type(a)          (int)(PyArray_TYPE((PyArrayObject*)a))
#define array_numdims(a)       (((PyArrayObject*)a)->nd)
#define array_dimensions(a)    (((PyArrayObject*)a)->dimensions)
#define array_size(a,i)        (((PyArrayObject*)a)->dimensions[i])
#define array_strides(a)       (((PyArrayObject*)a)->strides)
#define array_stride(a,i)      (((PyArrayObject*)a)->strides[i])
#define array_data(a)          (((PyArrayObject*)a)->data)
#define array_descr(a)         (((PyArrayObject*)a)->descr)
#define array_flags(a)         (((PyArrayObject*)a)->flags)
#define array_clearflags(a,f)  (((PyArrayObject*)a)->flags) &= ~f
#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f
#define array_is_fortran(a)    (PyArray_ISFORTRAN((PyArrayObject*)a))
#else
#define is_array(a)            ((a) && PyArray_Check(a))
#define array_type(a)          PyArray_TYPE((PyArrayObject*)a)
#define array_numdims(a)       PyArray_NDIM((PyArrayObject*)a)
#define array_dimensions(a)    PyArray_DIMS((PyArrayObject*)a)
#define array_strides(a)       PyArray_STRIDES((PyArrayObject*)a)
#define array_stride(a,i)      PyArray_STRIDE((PyArrayObject*)a,i)
#define array_size(a,i)        PyArray_DIM((PyArrayObject*)a,i)
#define array_data(a)          PyArray_DATA((PyArrayObject*)a)
#define array_descr(a)         PyArray_DESCR((PyArrayObject*)a)
#define array_flags(a)         PyArray_FLAGS((PyArrayObject*)a)
#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f)
#define array_clearflags(a,f)  PyArray_CLEARFLAGS((PyArrayObject*)a,f)
#define array_is_fortran(a)    (PyArray_IS_F_CONTIGUOUS((PyArrayObject*)a))
#endif
#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a))
#define array_is_native(a)     (PyArray_ISNOTSWAPPED((PyArrayObject*)a))


  /* Given a PyObject, return a string describing its type.
   */
  const char* pytype_string(PyObject* py_obj)
  {
    if (py_obj == NULL          ) return "C NULL value";
    if (py_obj == Py_None       ) return "Python None" ;
    if (PyCallable_Check(py_obj)) return "callable"    ;
    if (PyBytes_Check(   py_obj)) return "string"      ;
    if (PyLong_Check(    py_obj)) return "int"         ;
    if (PyFloat_Check(   py_obj)) return "float"       ;
    if (PyDict_Check(    py_obj)) return "dict"        ;
    if (PyList_Check(    py_obj)) return "list"        ;
    if (PyTuple_Check(   py_obj)) return "tuple"       ;

    return "unknown type";
  }

  /* Given a NumPy typecode, return a string describing the type.
   */
  const char* typecode_string(int typecode)
  {
    static const char* type_names[25] = {"bool",
                                         "byte",
                                         "unsigned byte",
                                         "short",
                                         "unsigned short",
                                         "int",
                                         "unsigned int",
                                         "long",
                                         "unsigned long",
                                         "long long",
                                         "unsigned long long",
                                         "float",
                                         "double",
                                         "long double",
                                         "complex float",
                                         "complex double",
                                         "complex long double",
                                         "object",
                                         "string",
                                         "unicode",
                                         "void",
                                         "ntypes",
                                         "notype",
                                         "char",
                                         "unknown"};
    return typecode < 24 ? type_names[typecode] : type_names[24];
  }

  /* Make sure input has correct numpy type.  This now just calls
     PyArray_EquivTypenums().
   */
  int type_match(int actual_type,
                 int desired_type)
  {
    return PyArray_EquivTypenums(actual_type, desired_type);
  }

#ifdef SWIGPY_USE_CAPSULE
  void free_cap(PyObject * cap)
  {
    void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME);
    if (array != NULL) free(array);
  }
#endif




  /* Given a PyObject pointer, cast it to a PyArrayObject pointer if
   * legal.  If not, set the python error string appropriately and
   * return NULL.
   */
  PyArrayObject* obj_to_array_no_conversion(PyObject* input,
                                            int        typecode)
  {
    PyArrayObject* ary = NULL;
    if (is_array(input) && (typecode == NPY_NOTYPE ||
                            PyArray_EquivTypenums(array_type(input), typecode)))
    {
      ary = (PyArrayObject*) input;
    }
    else if is_array(input)
    {
      const char* desired_type = typecode_string(typecode);
      const char* actual_type  = typecode_string(array_type(input));
      PyErr_Format(PyExc_TypeError,
                   "Array of type '%s' required.  Array of type '%s' given",
                   desired_type, actual_type);
      ary = NULL;
    }
    else
    {
      const char* desired_type = typecode_string(typecode);
      const char* actual_type  = pytype_string(input);
      PyErr_Format(PyExc_TypeError,
                   "Array of type '%s' required.  A '%s' was given",
                   desired_type,
                   actual_type);
      ary = NULL;
    }
    return ary;
  }

  /* Convert the given PyObject to a NumPy array with the given
   * typecode.  On success, return a valid PyArrayObject* with the
   * correct type.  On failure, the python error string will be set and
   * the routine returns NULL.
   */
  PyArrayObject* obj_to_array_allow_conversion(PyObject* input,
                                               int       typecode,
                                               int*      is_new_object)
  {
    PyArrayObject* ary = NULL;
    PyObject*      py_obj;
    if (is_array(input) && (typecode == NPY_NOTYPE ||
                            PyArray_EquivTypenums(array_type(input),typecode)))
    {
      ary = (PyArrayObject*) input;
      *is_new_object = 0;
    }
    else
    {
      py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT);
      /* If NULL, PyArray_FromObject will have set python error value.*/
      ary = (PyArrayObject*) py_obj;
      *is_new_object = 1;
    }
    return ary;
  }

  /* Given a PyArrayObject, check to see if it is contiguous.  If so,
   * return the input pointer and flag it as not a new object.  If it is
   * not contiguous, create a new PyArrayObject using the original data,
   * flag it as a new object and return the pointer.
   */
  PyArrayObject* make_contiguous(PyArrayObject* ary,
                                 int*           is_new_object,
                                 int            min_dims,
                                 int            max_dims)
  {
    PyArrayObject* result;
    if (array_is_contiguous(ary))
    {
      result = ary;
      *is_new_object = 0;
    }
    else
    {
      result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,
                                                              array_type(ary),
                                                              min_dims,
                                                              max_dims);
      *is_new_object = 1;
    }
    return result;
  }

  /* Given a PyArrayObject, check to see if it is Fortran-contiguous.
   * If so, return the input pointer, but do not flag it as not a new
   * object.  If it is not Fortran-contiguous, create a new
   * PyArrayObject using the original data, flag it as a new object
   * and return the pointer.
   */
  PyArrayObject* make_fortran(PyArrayObject* ary,
                              int*           is_new_object)
  {
    PyArrayObject* result;
    if (array_is_fortran(ary))
    {
      result = ary;
      *is_new_object = 0;
    }
    else
    {
      Py_INCREF(array_descr(ary));
      result = (PyArrayObject*) PyArray_FromArray(ary,
                                                  array_descr(ary),
#if NPY_API_VERSION < 0x00000007
                                                  NPY_FORTRANORDER);
#else
                                                  NPY_ARRAY_F_CONTIGUOUS);
#endif
      *is_new_object = 1;
    }
    return result;
  }

  /* Convert a given PyObject to a contiguous PyArrayObject of the
   * specified type.  If the input object is not a contiguous
   * PyArrayObject, a new one will be created and the new object flag
   * will be set.
   */
  PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
                                                          int       typecode,
                                                          int*      is_new_object)
  {
    int is_new1 = 0;
    int is_new2 = 0;
    PyArrayObject* ary2;
    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
                                                        typecode,
                                                        &is_new1);
    if (ary1)
    {
      ary2 = make_contiguous(ary1, &is_new2, 0, 0);
      if ( is_new1 && is_new2)
      {
        Py_DECREF(ary1);
      }
      ary1 = ary2;
    }
    *is_new_object = is_new1 || is_new2;
    return ary1;
  }

  /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the
   * specified type.  If the input object is not a Fortran-ordered
   * PyArrayObject, a new one will be created and the new object flag
   * will be set.
   */
  PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,
                                                       int       typecode,
                                                       int*      is_new_object)
  {
    int is_new1 = 0;
    int is_new2 = 0;
    PyArrayObject* ary2;
    PyArrayObject* ary1 = obj_to_array_allow_conversion(input,
                                                        typecode,
                                                        &is_new1);
    if (ary1)
    {
      ary2 = make_fortran(ary1, &is_new2);
      if (is_new1 && is_new2)
      {
        Py_DECREF(ary1);
      }
      ary1 = ary2;
    }
    *is_new_object = is_new1 || is_new2;
    return ary1;
  }


  /* Test whether a python object is contiguous.  If array is
   * contiguous, return 1.  Otherwise, set the python error string and
   * return 0.
   */
  int require_contiguous(PyArrayObject* ary)
  {
    int contiguous = 1;
    if (!array_is_contiguous(ary))
    {
      PyErr_SetString(PyExc_TypeError,
                      "Array must be contiguous.  A non-contiguous array was given");
      contiguous = 0;
    }
    return contiguous;
  }

  /* Test whether a python object is (C_ or F_) contiguous.  If array is
   * contiguous, return 1.  Otherwise, set the python error string and
   * return 0.
   */
  int require_c_or_f_contiguous(PyArrayObject* ary)
  {
    int contiguous = 1;
    if (!(array_is_contiguous(ary) || array_is_fortran(ary)))
    {
      PyErr_SetString(PyExc_TypeError,
                      "Array must be contiguous (C_ or F_).  A non-contiguous array was given");
      contiguous = 0;
    }
    return contiguous;
  }

  /* Require that a numpy array is not byte-swapped.  If the array is
   * not byte-swapped, return 1.  Otherwise, set the python error string
   * and return 0.
   */
  int require_native(PyArrayObject* ary)
  {
    int native = 1;
    if (!array_is_native(ary))
    {
      PyErr_SetString(PyExc_TypeError,
                      "Array must have native byteorder.  "
                      "A byte-swapped array was given");
      native = 0;
    }
    return native;
  }

  /* Require the given PyArrayObject to have a specified number of
   * dimensions.  If the array has the specified number of dimensions,
   * return 1.  Otherwise, set the python error string and return 0.
   */
  int require_dimensions(PyArrayObject* ary,
                         int            exact_dimensions)
  {
    int success = 1;
    if (array_numdims(ary) != exact_dimensions)
    {
      PyErr_Format(PyExc_TypeError,
                   "Array must have %d dimensions.  Given array has %d dimensions",
                   exact_dimensions,
                   array_numdims(ary));
      success = 0;
    }
    return success;
  }

  /* Require the given PyArrayObject to have one of a list of specified
   * number of dimensions.  If the array has one of the specified number
   * of dimensions, return 1.  Otherwise, set the python error string
   * and return 0.
   */
  int require_dimensions_n(PyArrayObject* ary,
                           int*           exact_dimensions,
                           int            n)
  {
    int success = 0;
    int i;
    char dims_str[255] = "";
    char s[255];
    for (i = 0; i < n && !success; i++)
    {
      if (array_numdims(ary) == exact_dimensions[i])
      {
        success = 1;
      }
    }
    if (!success)
    {
      for (i = 0; i < n-1; i++)
      {
        sprintf(s, "%d, ", exact_dimensions[i]);
        strcat(dims_str,s);
      }
      sprintf(s, " or %d", exact_dimensions[n-1]);
      strcat(dims_str,s);
      PyErr_Format(PyExc_TypeError,
                   "Array must have %s dimensions.  Given array has %d dimensions",
                   dims_str,
                   array_numdims(ary));
    }
    return success;
  }

  /* Require the given PyArrayObject to have a specified shape.  If the
   * array has the specified shape, return 1.  Otherwise, set the python
   * error string and return 0.
   */
  int require_size(PyArrayObject* ary,
                   npy_intp*      size,
                   int            n)
  {
    int i;
    int success = 1;
    size_t len;
    char desired_dims[255] = "[";
    char s[255];
    char actual_dims[255] = "[";
    for(i=0; i < n;i++)
    {
      if (size[i] != -1 &&  size[i] != array_size(ary,i))
      {
        success = 0;
      }
    }
    if (!success)
    {
      for (i = 0; i < n; i++)
      {
        if (size[i] == -1)
        {
          sprintf(s, "*,");
        }
        else
        {
          sprintf(s, "%ld,", (long int)size[i]);
        }
        strcat(desired_dims,s);
      }
      len = strlen(desired_dims);
      desired_dims[len-1] = ']';
      for (i = 0; i < n; i++)
      {
        sprintf(s, "%ld,", (long int)array_size(ary,i));
        strcat(actual_dims,s);
      }
      len = strlen(actual_dims);
      actual_dims[len-1] = ']';
      PyErr_Format(PyExc_TypeError,
                   "Array must have shape of %s.  Given array has shape of %s",
                   desired_dims,
                   actual_dims);
    }
    return success;
  }

  /* Require the given PyArrayObject to be Fortran ordered.  If the
   * the PyArrayObject is already Fortran ordered, do nothing.  Else,
   * set the Fortran ordering flag and recompute the strides.
   */
  int require_fortran(PyArrayObject* ary)
  {
    int success = 1;
    int nd = array_numdims(ary);
    int i;
    npy_intp * strides = array_strides(ary);
    if (array_is_fortran(ary)) return success;
    int n_non_one = 0;
    /* Set the Fortran ordered flag */
    const npy_intp *dims = array_dimensions(ary);
    for (i=0; i < nd; ++i)
      n_non_one += (dims[i] != 1) ? 1 : 0;
    if (n_non_one > 1)
      array_clearflags(ary,NPY_ARRAY_CARRAY);
    array_enableflags(ary,NPY_ARRAY_FARRAY);
    /* Recompute the strides */
    strides[0] = strides[nd-1];
    for (i=1; i < nd; ++i)
      strides[i] = strides[i-1] * array_size(ary,i-1);
    return success;
  }




SWIGINTERN int
SWIG_AsVal_double (PyObject *obj, double *val)
{
  int res = SWIG_TypeError;
  if (PyFloat_Check(obj)) {
    if (val) *val = PyFloat_AsDouble(obj);
    return SWIG_OK;
#if PY_VERSION_HEX < 0x03000000
  } else if (PyInt_Check(obj)) {
    if (val) *val = (double) PyInt_AsLong(obj);
    return SWIG_OK;
#endif
  } else if (PyLong_Check(obj)) {
    double v = PyLong_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    double d = PyFloat_AsDouble(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = d;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      long v = PyLong_AsLong(obj);
      if (!PyErr_Occurred()) {
	if (val) *val = v;
	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
      } else {
	PyErr_Clear();
      }
    }
  }
#endif
  return res;
}


    void axisar_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "axisar" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            axisar_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


#include <limits.h>
#if !defined(SWIG_NO_LLONG_MAX)
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
#   define LLONG_MAX __LONG_LONG_MAX__
#   define LLONG_MIN (-LLONG_MAX - 1LL)
#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
# endif
#endif


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_long (PyObject *obj, long* val)
{
#if PY_VERSION_HEX < 0x03000000
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AsLong(obj);
    return SWIG_OK;
  } else
#endif
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_OK;
    } else {
      PyErr_Clear();
      return SWIG_OverflowError;
    }
  }
#ifdef SWIG_PYTHON_CAST_MODE
  {
    int dispatch = 0;
    long v = PyInt_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return SWIG_AddCast(SWIG_OK);
    } else {
      PyErr_Clear();
    }
    if (!dispatch) {
      double d;
      int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
#endif
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int (PyObject * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (int)(v);
    }
  }  
  return res;
}


    void my_bltfrm_c(
        SpiceInt frmcls,
        SpiceInt ids[MAXIDS], SpiceInt *count)
    {
        int j;
        SPICEINT_CELL(cells, MAXIDS);

        scard_c(0, &cells);
        bltfrm_c(frmcls, &cells);

        *count = card_c(&cells);
        for (j = 0; j < *count; j++) {
            ids[j] = SPICE_CELL_ELEM_I(&cells, j);
        }
    }


SWIGINTERNINLINE PyObject*
  SWIG_From_int  (int value)
{
  return PyInt_FromLong((long) value);
}


    void my_ccifrm_c(
        SpiceInt frclss,
        SpiceInt clssid,
        SpiceInt *frcode,
        SpiceInt lenout, SpiceChar frname[NAMELEN],
        SpiceInt *center,
        SpiceBoolean *found)
    {
        ccifrm_c(frclss, clssid, lenout, frcode, frname, center, found);
    }


    void cgv2el_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "cgv2el" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NELLIPSE;

        SpiceDouble *out21_buffer = my_malloc(size * NELLIPSE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            cgv2el_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * NELLIPSE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_cidfrm_c(
        SpiceInt cent,
        SpiceInt *frcode,
        SpiceInt lenout, SpiceChar frname[NAMELEN],
        SpiceBoolean *found)
    {
        cidfrm_c(cent, lenout, frcode, frname, found);
    }


    void my_ckcov_c(
        ConstSpiceChar *ck,
        SpiceInt       idcode,
        SpiceBoolean   needav,
        ConstSpiceChar *level,
        SpiceDouble    tol,
        ConstSpiceChar *timsys,
        SpiceDouble cover[WINDOWS][2], SpiceInt *intervals)
    {
        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        ckcov_c(ck, idcode, needav, level, tol, timsys, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(cover[j][0]), &(cover[j][1]));
        }
    }


  #define SWIG_From_double   PyFloat_FromDouble 


    void ckgp_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceChar *str1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3,
        SpiceDouble **out11, int *out11_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "ckgp" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        SpiceDouble *out11_buffer = out31_buffer ? my_malloc(size, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out11_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out31_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ckgp_c(
                k1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                str1,
                out31_buffer + i * 3 * 3,
                out11_buffer + i,
                bool1_buffer + i);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void ckgpav_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceChar *str1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "ckgpav" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        SpiceDouble *out21_buffer = out31_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out11_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out31_buffer);
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ckgpav_c(
                k1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                str1,
                out31_buffer + i * 3 * 3,
                out21_buffer + i * 3,
                out11_buffer + i,
                bool1_buffer + i);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_ckobj_c(
        ConstSpiceChar *ck,
        SpiceInt bodids[MAXIDS], int *bodies)
    {
        int j;
        SPICEINT_CELL(ids, MAXIDS);

        scard_c(0, &ids);
        ckobj_c(ck, &ids);

        *bodies = card_c(&ids);
        for (j = 0; j < *bodies; j++) {
            bodids[j] = SPICE_CELL_ELEM_I(&ids, j);
        }
    }


    void my_cnmfrm_c(
        ConstSpiceChar *cname,
        SpiceInt       *frcode,
        SpiceInt lenout, SpiceChar frname[NAMELEN],
        SpiceBoolean   *found)
    {
        cnmfrm_c(cname, lenout, frcode, frname, found);
    }


    void conics_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "conics" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            conics_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void convrt_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "convrt" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            convrt_c(
                in11[i],
                str1,
                str2,
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void cyllat_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "cyllat" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            cyllat_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void cylrec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "cylrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            cylrec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void cylsph_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "cylsph" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            cylsph_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void dcyldr_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dcyldr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dcyldr_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void deltet_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "deltet" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            deltet_c(
                in11[i],
                str1,
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void det_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "det" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = det_c(
                in31 + (i) * in31_dim2 * in31_dim3);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void dgeodr_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dgeodr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dgeodr_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void diags2_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3,
        SpiceDouble **out32, int *out32_dim1, int *out32_dim2, int *out32_dim3) {
        char *my_name = "diags2" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 2; *out31_dim3 = 2;
        *out32 = NULL; *out32_dim1 = 0; *out32_dim2 = 2; *out32_dim3 = 2;

        SpiceDouble *out31_buffer = my_malloc(size * 2 * 2, my_name);
        SpiceDouble *out32_buffer = out31_buffer ? my_malloc(size * 2 * 2, my_name) : NULL;
        if (!out32_buffer) {
            free(out31_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            diags2_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 2 * 2,
                out32_buffer + i * 2 * 2);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
        *out32 = out32_buffer; *out32_dim1 = maxdim;
    }


    void dlatdr_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dlatdr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dlatdr_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void dpgrdr_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dpgrdr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dpgrdr_c(
                str1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void drdcyl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdcyl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdcyl_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void drdgeo_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdgeo" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdgeo_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void drdlat_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdlat" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdlat_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void drdpgr_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdpgr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdpgr_c(
                str1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void drdsph_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdsph" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdsph_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void dsphdr_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dsphdr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dsphdr_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void ducrss_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "ducrss" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            ducrss_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void dvcrss_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "dvcrss" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            dvcrss_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void dvdot_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "dvdot" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = dvdot_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void dvhat_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "dvhat" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            dvhat_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void dvnorm_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "dvnorm" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = dvnorm_c(
                in21 + (i) * in21_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void dvsep_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "dvsep" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = dvsep_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void edlimb_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "edlimb" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NELLIPSE;

        SpiceDouble *out21_buffer = my_malloc(size * NELLIPSE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            edlimb_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * NELLIPSE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_edterm_c(
        ConstSpiceChar *trmtyp,
        ConstSpiceChar *source,
        ConstSpiceChar *target,
        SpiceDouble    et,
        ConstSpiceChar *fixref,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        SpiceInt       npts,
        SpiceDouble    *trgepc,
        SpiceDouble    obspos[3],
        SpiceDouble    **trmpts, int *dim1, int *dim2)
    {
        *trmpts = NULL;
        *dim1 = 0;
        *dim2 = 3;

        SpiceDouble *result = my_malloc(npts * 3, "edterm");
        if (!result) return;

        edterm_c(trmtyp, source, target, et, fixref, abcorr, obsrvr, npts,
                 trgepc, obspos, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *trmpts = result;
        *dim1 = npts;
        *dim2 = 3;
    }


    void el2cgv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceDouble **out23, int *out23_dim1, int *out23_dim2) {
        char *my_name = "el2cgv" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *out23 = NULL; *out23_dim1 = 0; *out23_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out23_buffer = out22_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out23_buffer) {
            free(out21_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            el2cgv_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out22_buffer + i * 3,
                out23_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *out23 = out23_buffer; *out23_dim1 = maxdim;
    }


    void eqncpv_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "eqncpv" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            eqncpv_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_erract_c(
        ConstSpiceChar *op,
        SpiceInt lenout, SpiceChar action[NAMELEN])
    {
        if (eqstr_c(op, "GET")) {
            erract_c("GET", lenout, action);

            // Replace "RETURN" with the type of Python exception handling
            if (strcmp(action, "RETURN") == 0) {
                if (get_python_exception_flag()) {
                    strncpy(action, "RUNTIME", lenout);
                } else {
                    strncpy(action, "EXCEPTION", lenout);
                }
            }
        }

        else if (eqstr_c(op, "SET")) {
            if (eqstr_c(action, "EXCEPTION")) {
                set_python_exception_flag(0);
                erract_c("SET", lenout, "RETURN");
                strncpy(action, "EXCEPTION", lenout);
            }
            else if (eqstr_c(action, "RUNTIME")) {
                set_python_exception_flag(1);
                erract_c("SET", lenout, "RETURN");
                strncpy(action, "RUNTIME", lenout);
            }
            else if (eqstr_c(action, "REPORT")) {
                printf("Error action \"REPORT\" is not supported; using \"RETURN\"");
                erract_c("SET", lenout, "RETURN");
                strncpy(action, "RETURN", lenout);
            }
            else if (eqstr_c(action, "IGNORE")) {
                printf("Error action \"IGNORE\" is not supported; using \"RETURN\"");
                erract_c("SET", lenout, "RETURN");
                strncpy(action, "RETURN", lenout);
            }
            else {  // Only "RETURN", "ABORT", or "DEFAULT"
                    // These options do not change the Python exception handling
                erract_c("SET", NAMELEN, action);
            }
        }

        else {  // This is sure to generate an error condition
            erract_c(op, lenout, action);
        }
    }


    void my_et2lst_c(
        SpiceDouble    et,
        SpiceInt       body,
        SpiceDouble    lon,
        ConstSpiceChar *type,
        SpiceInt       *hr,
        SpiceInt       *mn,
        SpiceInt       *sc,
        SpiceInt timlen,  SpiceChar time[TIMELEN],
        SpiceInt ampmlen, SpiceChar ampm[10])
    {
        et2lst_c(et, body, lon, type, timlen, ampmlen,
                 hr, mn, sc, time, ampm);
    }


    void eul2m_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceInt k1,
        SpiceInt k2,
        SpiceInt k3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "eul2m" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            eul2m_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                k1,
                k2,
                k3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void eul2xf_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceInt k1,
        SpiceInt k2,
        SpiceInt k3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "eul2xf" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            eul2xf_c(
                in21 + (i) * in21_dim2,
                k1,
                k2,
                k3,
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_fovray_c(
        ConstSpiceChar   *inst,
        ConstSpiceDouble raydir[3],
        ConstSpiceChar   *rframe,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *obsrvr,
        SpiceDouble      et,
        SpiceBoolean     *visibl)
    {
        fovray_c(inst, raydir, rframe, abcorr, obsrvr, &et, visibl);
    }


    void fovray_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "fovray" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceBoolean *bool1_buffer = my_bool_malloc(size, my_name);
        if (!bool1_buffer) return;
        for (int i = 0; i < size; i++) {
            my_fovray_c(
                str1,
                in21 + (i % in21_dim1) * in21_dim2,
                str2,
                str3,
                str4,
                in11[i % in11_dim1],
                bool1_buffer + i);
        }

        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_fovtrg_c(
        ConstSpiceChar *inst,
        ConstSpiceChar *target,
        ConstSpiceChar *tshape,
        ConstSpiceChar *tframe,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        SpiceDouble    et,
        SpiceBoolean   *visibl)
    {
        fovtrg_c(inst, target, tshape, tframe, abcorr, obsrvr, &et, visibl);
    }


    void fovtrg_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "fovtrg" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceBoolean *bool1_buffer = my_bool_malloc(size, my_name);
        if (!bool1_buffer) return;
        for (int i = 0; i < size; i++) {
            my_fovtrg_c(
                str1,
                str2,
                str3,
                str4,
                str5,
                str6,
                in11[i],
                bool1_buffer + i);
        }

        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_frame_c(
        ConstSpiceDouble x1[3],
        SpiceDouble      x[3],
        SpiceDouble      y[3],
        SpiceDouble      z[3])
    {
        x[0] = x1[0];
        x[1] = x1[1];
        x[2] = x1[2];
        frame_c(x, y, z);
    }


    void frame_vector(
        SpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceDouble **out23, int *out23_dim1, int *out23_dim2) {
        char *my_name = "frame" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *out23 = NULL; *out23_dim1 = 0; *out23_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out23_buffer = out22_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out23_buffer) {
            free(out21_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_frame_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out22_buffer + i * 3,
                out23_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *out23 = out23_buffer; *out23_dim1 = maxdim;
    }


    void my_frmchg(
        SpiceInt    frame1,
        SpiceInt    frame2,
        SpiceDouble et,
        SpiceDouble xform[6][6])
    {
        frmchg_(&frame1, &frame2, &et, xform);
    }


    void frmchg_vector(
        SpiceInt k1,
        SpiceInt k2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "frmchg" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_frmchg(
                k1,
                k2,
                in11[i],
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void georec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "georec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            georec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_getfov_c(
        SpiceInt instid,
        SpiceInt shapelen, SpiceChar shape[NAMELEN],
        SpiceInt framelen, SpiceChar frame[NAMELEN],
        SpiceDouble bsight[3],
        SpiceInt *size1, SpiceInt *size2, SpiceDouble bounds[FOVSHAPE][3])
    {
        getfov_c(instid, MAXFOV, shapelen, framelen, shape, frame,
                 bsight, size1, bounds);
        *size2 = 3;
    }


    void my_getmsg_c(
        ConstSpiceChar *option,
        SpiceInt lenout, SpiceChar msg[LONGMSGLEN])
    {
        if (eqstr_c(option, "SHORT")) {
            strncpy(msg, get_message_after_reset(0), LONGMSGLEN);
        }
        else if (eqstr_c(option,"LONG")) {
            strncpy(msg, get_message_after_reset(1), LONGMSGLEN);
        }
        else if (eqstr_c(option,"EXPLAIN")) {
            strncpy(msg, get_message_after_reset(2), LONGMSGLEN);
        }
        else {
            msg[0] = '\0';
        }

        if (msg[0] == '\0') {
            getmsg_c(option, lenout, msg);
        }
    }


    void illum_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "illum" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            illum_c(
                str1,
                in11[i % in11_dim1],
                str2,
                str3,
                in21 + (i % in21_dim1) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void illumf_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1,
        SpiceDouble **out14, int *out14_dim1,
        SpiceBoolean **bool1, int *bool1_dim1,
        SpiceBoolean **bool2, int *bool2_dim1) {
        char *my_name = "illumf" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;
        *out14 = NULL; *out14_dim1 = 0;
        *bool1 = NULL; *bool1_dim1 = 0;
        *bool2 = NULL; *bool2_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out21_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out12_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out14_buffer = out13_buffer ? my_malloc(size, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out14_buffer ? my_bool_malloc(size, my_name) : NULL;
        SpiceBoolean *bool2_buffer = bool1_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool2_buffer) {
            free(out11_buffer);
            free(out21_buffer);
            free(out12_buffer);
            free(out13_buffer);
            free(out14_buffer);
            free(bool1_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            illumf_c(
                str1,
                str2,
                str3,
                in11[i % in11_dim1],
                str4,
                str5,
                str6,
                in21 + (i % in21_dim1) * in21_dim2,
                out11_buffer + i,
                out21_buffer + i * 3,
                out12_buffer + i,
                out13_buffer + i,
                out14_buffer + i,
                bool1_buffer + i,
                bool2_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
        *out14 = out14_buffer; *out14_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
        *bool2 = bool2_buffer; *bool2_dim1 = maxdim;
    }


    void illumg_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1,
        SpiceDouble **out14, int *out14_dim1) {
        char *my_name = "illumg" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;
        *out14 = NULL; *out14_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out21_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out12_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out14_buffer = out13_buffer ? my_malloc(size, my_name) : NULL;
        if (!out14_buffer) {
            free(out11_buffer);
            free(out21_buffer);
            free(out12_buffer);
            free(out13_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            illumg_c(
                str1,
                str2,
                str3,
                in11[i % in11_dim1],
                str4,
                str5,
                str6,
                in21 + (i % in21_dim1) * in21_dim2,
                out11_buffer + i,
                out21_buffer + i * 3,
                out12_buffer + i,
                out13_buffer + i,
                out14_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
        *out14 = out14_buffer; *out14_dim1 = maxdim;
    }


    void ilumin_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1,
        SpiceDouble **out14, int *out14_dim1) {
        char *my_name = "ilumin" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;
        *out14 = NULL; *out14_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out21_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out12_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out14_buffer = out13_buffer ? my_malloc(size, my_name) : NULL;
        if (!out14_buffer) {
            free(out11_buffer);
            free(out21_buffer);
            free(out12_buffer);
            free(out13_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ilumin_c(
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                str4,
                str5,
                in21 + (i % in21_dim1) * in21_dim2,
                out11_buffer + i,
                out21_buffer + i * 3,
                out12_buffer + i,
                out13_buffer + i,
                out14_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
        *out14 = out14_buffer; *out14_dim1 = maxdim;
    }


    void inedpl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "inedpl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NELLIPSE;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * NELLIPSE, my_name);
        SpiceBoolean *bool1_buffer = out21_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            inedpl_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * NELLIPSE,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void inelpl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceInt **int1, int *int1_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "inelpl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *int1 = NULL; *int1_dim1 = 0;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        SpiceDouble *out21_buffer = int1_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out22_buffer) {
            free(int1_buffer);
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            inelpl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                int1_buffer + i,
                out21_buffer + i * 3,
                out22_buffer + i * 3);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void inrypl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceInt **int1, int *int1_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "inrypl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *int1 = NULL; *int1_dim1 = 0;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        SpiceDouble *out21_buffer = int1_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out21_buffer) {
            free(int1_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            inrypl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                int1_buffer + i,
                out21_buffer + i * 3);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void invert_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "invert" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            invert_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void invort_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "invort" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            invort_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void isrot_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "isrot" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceBoolean *bool1_buffer = my_bool_malloc(size, my_name);
        if (!bool1_buffer) return;
        for (int i = 0; i < size; i++) {
            bool1_buffer[i] = isrot_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in11[i % in11_dim1],
                in12[i % in12_dim1]);
        }

        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_kplfrm_c(
        SpiceInt frmcls,
        SpiceInt ids[MAXIDS], SpiceInt *count)
    {
        int j;
        SPICEINT_CELL(cells, MAXIDS);

        scard_c(0, &cells);
        kplfrm_c(frmcls, &cells);

        *count = card_c(&cells);
        for (j = 0; j < *count; j++) {
            ids[j] = SPICE_CELL_ELEM_I(&cells, j);
        }
    }


    void latcyl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "latcyl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            latcyl_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void latrec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "latrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            latrec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_latsrf_c(
        ConstSpiceChar   *method,
        ConstSpiceChar   *target,
        SpiceDouble      et,
        ConstSpiceChar   *fixref,
        ConstSpiceDouble lonlat[][2], SpiceInt npts,
        SpiceDouble      **srfpts, int *sdim1, int *sdim2)
    {
        *srfpts = NULL;
        *sdim1 = 0;
        *sdim2 = 3;

        SpiceDouble *srfpts1 = my_malloc(npts * 3, "latsrf");
        if (!srfpts1) return;

        latsrf_c(method, target, et, fixref, npts, lonlat, srfpts1);

        if (failed_c()) {
            free(srfpts1);
            return;
        }

        *srfpts = srfpts1;
        *sdim1 = npts;
        *sdim2 = 3;
    }


    void latsph_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "latsph" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            latsph_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void my_limbpt_c(
        ConstSpiceChar   *method,
        ConstSpiceChar   *target,
        SpiceDouble      et,
        ConstSpiceChar   *fixref,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *corloc,
        ConstSpiceChar   *obsrvr,
        ConstSpiceDouble refvec[3],
        SpiceDouble      rolstp,
        SpiceInt         ncuts,
        SpiceDouble      schstp,
        SpiceDouble      soltol,
        SpiceInt         maxn,
        SpiceInt         **npts,
        SpiceInt         *ndim1,
        SpiceDouble **points, int *pdim1, int *pdim2,
        SpiceDouble **epochs, int *edim1,
        SpiceDouble **tangts, int *tdim1, int *tdim2)
    {
        *npts = NULL;
        *ndim1 = 0;

        *points = NULL;
        *pdim1 = 0;
        *pdim2 = 3;

        *epochs = NULL;
        *edim1 = 0;

        *tangts = NULL;
        *tdim1 = 0;
        *tdim2 = 3;

        SpiceInt    *npts1 = my_int_malloc(maxn,   "limbpt");
        SpiceDouble *points1 = my_malloc(maxn * 3, "limbpt");
        SpiceDouble *epochs1 = my_malloc(maxn,     "limbpt");
        SpiceDouble *tangts1 = my_malloc(maxn * 3, "limbpt");

        if (!tangts1) {
            free(npts1);
            free(points1);
            free(epochs1);
            free(tangts1);
            return;
        }

        limbpt_c(method, target, et, fixref, abcorr, corloc, obsrvr, refvec,
                 rolstp, ncuts, schstp, soltol, maxn,
                 npts1, points1, epochs1, tangts1);

        if (failed_c()) {
            free(npts1);
            free(points1);
            free(epochs1);
            free(tangts1);
            return;
        }

        *npts = npts1;
        *ndim1 = maxn;

        *points = points1;
        *pdim1 = maxn;
        *pdim2 = 3;

        *epochs = epochs1;
        *edim1 = maxn;

        *tangts = tangts1;
        *tdim1 = maxn;
        *tdim2 = 3;
    }


    void lspcn_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "lspcn" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = lspcn_c(
                str1,
                in11[i],
                str2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void ltime_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceInt k1,
        ConstSpiceChar *str1,
        SpiceInt k2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "ltime" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ltime_c(
                in11[i],
                k1,
                str1,
                k2,
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void m2eul_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceInt k1,
        SpiceInt k2,
        SpiceInt k3,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "m2eul" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            m2eul_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                k1,
                k2,
                k3,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void m2q_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "m2q" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 4;

        SpiceDouble *out21_buffer = my_malloc(size * 4, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            m2q_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out21_buffer + i * 4);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void mequ_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mequ" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            mequ_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_mequg_c(
        SpiceDouble *m1,    SpiceInt nr, SpiceInt nc,
        SpiceDouble **matrix, int *nr_out, int *nc_out)
    {
        *matrix = NULL;
        *nr_out = 0;
        *nc_out = 0;

        SpiceDouble *result = my_malloc(nr * nc, "mequg");
        if (!result) return;

        mequg_c(m1, nr, nc, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *matrix = result;
        *nr_out = nr;
        *nc_out = nc;
    }

    void my_mequg_nomalloc(
        ConstSpiceDouble *m1, SpiceInt nr, SpiceInt nc,
        SpiceDouble  *matrix, int *nr_out, int *nc_out)
    {
        mequg_c(m1, nr, nc, matrix);
        *nr_out = nr;
        *nc_out = nc;
    }


    void mequg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mequg" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = in31_dim2; *out31_dim3 = in31_dim3;

        SpiceDouble *out31_buffer = my_malloc(size * in31_dim2 * in31_dim3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mequg_nomalloc(
                in31 + (i) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                out31_buffer + i * in31_dim2 * in31_dim3, out31_dim2, out31_dim3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void mtxm_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mtxm" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            mtxm_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_mtxmg_c(
        SpiceDouble  *m1, SpiceInt  nr1, SpiceInt  nc1,
        SpiceDouble  *m2, SpiceInt  nr2, SpiceInt  nc2,
        SpiceDouble **m3, SpiceInt *nr3, SpiceInt *nc3)
    {
        *m3 = NULL;
        *nr3 = 0;
        *nc3 = 0;

        if (!my_assert_eq(nr1, nr2, "mtmxg",
            "Array dimension mismatch in mtmxg: "
            "matrix 1 rows = #; matrix 2 rows = #")) return;

        SpiceDouble *result = my_malloc(nc1 * nc2, "mtmxg");
        if (!result) return;

        mtxmg_c(m1, m2, nc1, nr1, nc2, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *m3 = result;
        *nr3 = nc1;
        *nc3 = nc2;
    }

    void my_mtxmg_nomalloc(
        SpiceDouble *m1, SpiceInt  nr1, SpiceInt  nc1,
        SpiceDouble *m2, SpiceInt  nr2, SpiceInt  nc2,
        SpiceDouble *m3, SpiceInt *nr3, SpiceInt *nc3)
    {
        if (!my_assert_eq(nr1, nr2, "mtmxg",
            "Array dimension mismatch in mtmxg: "
            "matrix 1 rows = #; matrix 2 rows = #")) return;

        mtxmg_c(m1, m2, nc1, nr1, nc2, m3);
        *nr3 = nc1;
        *nc3 = nc2;
    }


    void mtxmg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mtxmg" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = in31_dim3; *out31_dim3 = in32_dim3;

        SpiceDouble *out31_buffer = my_malloc(size * in31_dim3 * in32_dim3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mtxmg_nomalloc(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3, in32_dim2, in32_dim3,
                out31_buffer + i * in31_dim3 * in32_dim3, out31_dim2, out31_dim3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void mtxv_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "mtxv" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            mtxv_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_mtxvg_c(
        SpiceDouble  *m1, SpiceInt  nr1, SpiceInt nc1,
        SpiceDouble  *v2, SpiceInt  nr2,
        SpiceDouble **v3, SpiceInt *nr3)
    {
        *v3 = NULL;
        *nr3 = 0;

        if (!my_assert_eq(nr1, nr2, "mtxvg",
            "Array dimension mismatch in mtxvg: "
            "matrix rows = #; vector dimension = #")) return;

        SpiceDouble *result = my_malloc(nc1, "mtxvg");
        if (!result) return;

        mtxvg_c(m1, v2, nc1, nr1, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v3 = result;
        *nr3 = nc1;
    }

    void my_mtxvg_nomalloc(
        ConstSpiceDouble *m1, SpiceInt nr1, SpiceInt nc1,
        ConstSpiceDouble *v2, SpiceInt nr2,
        SpiceDouble      *v3, int      *nr3)
    {
        if (!my_assert_eq(nr1, nr2, "mtxvg",
            "Array dimension mismatch in mtxvg: "
            "matrix rows = #; vector dimension = #")) return;

        mtxvg_c(m1, v2, nc1, nr1, v3);
        *nr3 = nc1;
    }


    void mtxvg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "mtxvg" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in31_dim3;

        SpiceDouble *out21_buffer = my_malloc(size * in31_dim3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mtxvg_nomalloc(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                out21_buffer + i * in31_dim3, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void mxm_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mxm" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            mxm_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_mxmg_c(
        SpiceDouble  *m1, SpiceInt  nr1, SpiceInt  nc1,
        SpiceDouble  *m2, SpiceInt  nr2, SpiceInt  nc2,
        SpiceDouble **m3, SpiceInt *nr3, SpiceInt *nc3)
    {
        *m3 = NULL;
        *nr3 = 0;
        *nc3 = 0;

        if (!my_assert_eq(nc1, nr2, "mxmg",
            "Array dimension mismatch in mxmg: "
            "matrix 1 columns = #; matrix 2 rows = #")) return;

        SpiceDouble *result = my_malloc(nr1 * nc2, "mxmg");
        if (!result) return;

        mxmg_c(m1, m2, nr1, nc1, nc2, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *m3 = result;
        *nr3 = nr1;
        *nc3 = nc2;
    }

    void my_mxmg_nomalloc(
        SpiceDouble *m1, SpiceInt  nr1, SpiceInt  nc1,
        SpiceDouble *m2, SpiceInt  nr2, SpiceInt  nc2,
        SpiceDouble *m3, SpiceInt *nr3, SpiceInt *nc3)
    {

        if (!my_assert_eq(nc1, nr2, "mxmg",
            "Array dimension mismatch in mxmg: "
            "matrix 1 columns = #; matrix 2 rows = #")) return;

        mxmg_c(m1, m2, nr1, nc1, nc2, m3);
        *nr3 = nr1;
        *nc3 = nc2;
    }


    void mxmg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mxmg" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = in31_dim2; *out31_dim3 = in32_dim3;

        SpiceDouble *out31_buffer = my_malloc(size * in31_dim2 * in32_dim3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mxmg_nomalloc(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3, in32_dim2, in32_dim3,
                out31_buffer + i * in31_dim2 * in32_dim3, out31_dim2, out31_dim3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void mxmt_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mxmt" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            mxmt_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_mxmtg_c(
        SpiceDouble  *m1, SpiceInt nr1, SpiceInt nc1,
        SpiceDouble  *m2, SpiceInt nr2, SpiceInt nc2,
        SpiceDouble **m3, int     *nr3, int     *nc3)
    {
        *m3 = NULL;
        *nr3 = 0;
        *nc3 = 0;

        if (!my_assert_eq(nc1, nc2, "mxmtg",
            "Array dimension mismatch in mxmtg: "
            "matrix 1 columns = #; matrix 2 columns = #")) return;

        SpiceDouble *result = my_malloc(nr1 * nr2, "mxmtg");
        if (!result) return;

        mxmtg_c(m1, m2, nr1, nc1, nr2, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *m3 = result;
        *nr3 = nr1;
        *nc3 = nr2;
    }

    void my_mxmtg_nomalloc(
        SpiceDouble *m1, SpiceInt nr1, SpiceInt nc1,
        SpiceDouble *m2, SpiceInt nr2, SpiceInt nc2,
        SpiceDouble *m3, int     *nr3, int     *nc3)
    {
        if (!my_assert_eq(nc1, nc2, "mxmtg",
            "Array dimension mismatch in mxmtg: "
            "matrix 1 columns = #; matrix 2 columns = #")) return;

        mxmtg_c(m1, m2, nr1, nc1, nr2, m3);
        *nr3 = nr1;
        *nc3 = nr2;
    }


    void mxmtg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in32, int in32_dim1, int in32_dim2, int in32_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "mxmtg" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in32_dim1) maxdim = in32_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in32_dim1 = (in32_dim1 == 0 ? 1 : in32_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = in31_dim2; *out31_dim3 = in32_dim2;

        SpiceDouble *out31_buffer = my_malloc(size * in31_dim2 * in32_dim2, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mxmtg_nomalloc(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in32 + (i % in32_dim1) * in32_dim2 * in32_dim3, in32_dim2, in32_dim3,
                out31_buffer + i * in31_dim2 * in32_dim2, out31_dim2, out31_dim3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void mxv_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "mxv" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            mxv_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_mxvg_c(
        SpiceDouble  *m1, SpiceInt nr1, SpiceInt nc1,
        SpiceDouble  *v2, SpiceInt nr2,
        SpiceDouble **v3, int      *nr3)
    {
        *v3 = NULL;
        *nr3 = 0;

        if (!my_assert_eq(nc1, nr2, "mxvg",
            "Array dimension mismatch in mxvg: "
            "matrix columns = #; vector length = #")) return;

        SpiceDouble *result = my_malloc(nr1, "mxvg");
        if (!result) return;

        mxvg_c(m1, v2, nr1, nc1, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v3 = result;
        *nr3 = nr1;
    }

    void my_mxvg_nomalloc(
        SpiceDouble *m1, SpiceInt nr1, SpiceInt nc1,
        SpiceDouble *v2, SpiceInt nr2,
        SpiceDouble *v3, int     *nr3)
    {
        if (!my_assert_eq(nc1, nr2, "mxvg",
            "Array dimension mismatch in mxvg: "
            "matrix columns = #; vector dimension = #")) return;

        mxvg_c(m1, v2, nr1, nc1, v3);
        *nr3 = nr1;
    }


    void mxvg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "mxvg" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in31_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in31_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_mxvg_nomalloc(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                out21_buffer + i * in31_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void nearpt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "nearpt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            nearpt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void npedln_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "npedln" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            npedln_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void npelpt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "npelpt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            npelpt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void nplnpt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "nplnpt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            nplnpt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void nvc2pl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "nvc2pl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NPLANE;

        SpiceDouble *out21_buffer = my_malloc(size * NPLANE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            nvc2pl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                out21_buffer + i * NPLANE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void nvp2pl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "nvp2pl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NPLANE;

        SpiceDouble *out21_buffer = my_malloc(size * NPLANE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            nvp2pl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * NPLANE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void occult_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceChar *str7,
        ConstSpiceChar *str8,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceInt **int1, int *int1_dim1) {
        char *my_name = "occult" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *int1 = NULL; *int1_dim1 = 0;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        if (!int1_buffer) return;
        for (int i = 0; i < size; i++) {
            occult_c(
                str1,
                str2,
                str3,
                str4,
                str5,
                str6,
                str7,
                str8,
                in11[i],
                int1_buffer + i);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
    }


    void oscelt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "oscelt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 8;

        SpiceDouble *out21_buffer = my_malloc(size * 8, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            oscelt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out21_buffer + i * 8);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void oscltx_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "oscltx" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = SPICE_OSCLTX_NELTS;

        SpiceDouble *out21_buffer = my_malloc(size * SPICE_OSCLTX_NELTS, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            oscltx_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out21_buffer + i * SPICE_OSCLTX_NELTS);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_pckcov_c(
        ConstSpiceChar *pck,
        SpiceInt idcode,
        SpiceDouble cover[WINDOWS][2], int *intervals)
    {
        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        pckcov_c(pck, idcode, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(cover[j][0]), &(cover[j][1]));
        }
    }


    void my_pckfrm_c(
        ConstSpiceChar *pck,
        SpiceInt ids[MAXIDS], SpiceInt *frames)
    {
        int j;
        SPICEINT_CELL(cells, MAXIDS);

        scard_c(0, &cells);
        pckfrm_c(pck, &cells);

        *frames = card_c(&cells);
        for (j = 0; j < *frames; j++) {
            ids[j] = SPICE_CELL_ELEM_I(&cells, j);
        }
    }


    void pgrrec_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in14, int in14_dim1,
        ConstSpiceDouble *in15, int in15_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "pgrrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in14_dim1) maxdim = in14_dim1;
        if (maxdim < in15_dim1) maxdim = in15_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in14_dim1 = (in14_dim1 == 0 ? 1 : in14_dim1);
        in15_dim1 = (in15_dim1 == 0 ? 1 : in15_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            pgrrec_c(
                str1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in14[i % in14_dim1],
                in15[i % in15_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void phaseq_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "phaseq" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = phaseq_c(
                in11[i],
                str1,
                str2,
                str3,
                str4);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void pjelpl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "pjelpl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NELLIPSE;

        SpiceDouble *out21_buffer = my_malloc(size * NELLIPSE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            pjelpl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * NELLIPSE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void pltexp_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "pltexp" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            pltexp_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in11[i % in11_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void pltnp_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        ConstSpiceDouble *in24, int in24_dim1, int in24_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "pltnp" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;
        if (maxdim < in24_dim1) maxdim = in24_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);
        in24_dim1 = (in24_dim1 == 0 ? 1 : in24_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            pltnp_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                in24 + (i % in24_dim1) * in24_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void pl2nvc_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "pl2nvc" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            pl2nvc_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void pl2nvp_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "pl2nvp" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out22_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            pl2nvp_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out22_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void pl2psv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceDouble **out23, int *out23_dim1, int *out23_dim2) {
        char *my_name = "pl2psv" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *out23 = NULL; *out23_dim1 = 0; *out23_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out23_buffer = out22_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out23_buffer) {
            free(out21_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            pl2psv_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out22_buffer + i * 3,
                out23_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *out23 = out23_buffer; *out23_dim1 = maxdim;
    }


    void prop2b_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "prop2b" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            prop2b_c(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in12[i % in12_dim1],
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void psv2pl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "psv2pl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = NPLANE;

        SpiceDouble *out21_buffer = my_malloc(size * NPLANE, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            psv2pl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * NPLANE);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void pxform_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "pxform" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            pxform_c(
                str1,
                str2,
                in11[i],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void pxfrm2_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "pxfrm2" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            pxfrm2_c(
                str1,
                str2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void q2m_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "q2m" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            q2m_c(
                in21 + (i) * in21_dim2,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void qdq2av_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "qdq2av" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            qdq2av_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void qxq_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "qxq" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 4;

        SpiceDouble *out21_buffer = my_malloc(size * 4, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            qxq_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 4);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void radrec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "radrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            radrec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void rav2xf_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "rav2xf" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            rav2xf_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in21 + (i % in21_dim1) * in21_dim2,
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void raxisa_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "raxisa" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            raxisa_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void reccyl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "reccyl" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            reccyl_c(
                in21 + (i) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void recgeo_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "recgeo" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            recgeo_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void reclat_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "reclat" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            reclat_c(
                in21 + (i) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void recpgr_vector(
        ConstSpiceChar *str1,
        SpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "recpgr" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            recpgr_c(
                str1,
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void recrad_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "recrad" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            recrad_c(
                in21 + (i) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void recsph_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "recsph" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            recsph_c(
                in21 + (i) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void my_refchg(
        SpiceInt    frame1,
        SpiceInt    frame2,
        SpiceDouble et,
        SpiceDouble rotate[3][3])
    {
        refchg_(&frame1, &frame2, &et, rotate);
    }


    void refchg_vector(
        SpiceInt k1,
        SpiceInt k2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "refchg" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_refchg(
                k1,
                k2,
                in11[i],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
  if (PyBytes_Check(obj))
#else
  if (PyUnicode_Check(obj))
#endif
#else  
  if (PyString_Check(obj))
#endif
  {
    char *cstr; Py_ssize_t len;
    int ret = SWIG_OK;
#if PY_VERSION_HEX>=0x03000000
#if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    if (!alloc && cptr) {
        /* We can't allow converting without allocation, since the internal
           representation of string in Python 3 is UCS-2/UCS-4 but we require
           a UTF-8 representation.
           TODO(bhy) More detailed explanation */
        return SWIG_RuntimeError;
    }
    obj = PyUnicode_AsUTF8String(obj);
    if (!obj)
      return SWIG_TypeError;
    if (alloc)
      *alloc = SWIG_NEWOBJ;
#endif
    PyBytes_AsStringAndSize(obj, &cstr, &len);
#else
    PyString_AsStringAndSize(obj, &cstr, &len);
#endif
    if (cptr) {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
	  *alloc = SWIG_NEWOBJ;
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      } else {
#if PY_VERSION_HEX>=0x03000000
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
	*cptr = PyBytes_AsString(obj);
#else
	assert(0); /* Should never reach here with Unicode strings in Python 3 */
#endif
#else
	*cptr = SWIG_Python_str_AsChar(obj);
        if (!*cptr)
          ret = SWIG_TypeError;
#endif
      }
    }
    if (psize) *psize = len + 1;
#if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
    Py_XDECREF(obj);
#endif
    return ret;
  } else {
#if defined(SWIG_PYTHON_2_UNICODE)
#if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
#error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
#endif
#if PY_VERSION_HEX<0x03000000
    if (PyUnicode_Check(obj)) {
      char *cstr; Py_ssize_t len;
      if (!alloc && cptr) {
        return SWIG_RuntimeError;
      }
      obj = PyUnicode_AsUTF8String(obj);
      if (!obj)
        return SWIG_TypeError;
      if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
        if (cptr) {
          if (alloc) *alloc = SWIG_NEWOBJ;
          *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
        }
        if (psize) *psize = len + 1;

        Py_XDECREF(obj);
        return SWIG_OK;
      } else {
        Py_XDECREF(obj);
      }
    }
#endif
#endif

    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      void* vptr = 0;
      if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = (char *) vptr;
	if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    /* special case of single char conversion when we don't need space for NUL */
    if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	free((char*)cptr);
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) free((char*)cptr);
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = (char)(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


    void my_reset_c(void)
    {
        // An explict call to reset also clears the stored messages used for the
        // erract EXCEPTION option

        reset_c();
        reset_messages();
    }


    void rotate_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceInt k1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "rotate" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            rotate_c(
                in11[i],
                k1,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void rotmat_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceInt k1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "rotmat" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            rotmat_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in11[i % in11_dim1],
                k1,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void rotvec_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceInt k1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "rotvec" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            rotvec_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                k1,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void rquad_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "rquad" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 2;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 2;

        SpiceDouble *out21_buffer = my_malloc(size * 2, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 2, my_name) : NULL;
        if (!out22_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            rquad_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 2,
                out22_buffer + i * 2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void saelgv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "saelgv" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out22_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            saelgv_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3,
                out22_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void sce2c_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "sce2c" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            sce2c_c(
                k1,
                in11[i],
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void sce2t_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "sce2t" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            sce2t_c(
                k1,
                in11[i],
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_scpart_c(
        SpiceInt    sc,
        SpiceInt    *nparts, SpiceDouble pstart[SPICE_SCLK_MXPART],
        SpiceInt    *n1,     SpiceDouble pstop[SPICE_SCLK_MXPART])
    {
        scpart_c(sc, nparts, pstart, pstop);
        *n1 = *nparts;
    }


    void sct2e_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "sct2e" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            sct2e_c(
                k1,
                in11[i],
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_setmsg_c(
        ConstSpiceChar *message)
    {
        // A call to setmsg also clears the saved errors
        setmsg_c(message);
        reset_messages();
    }


    void sincpt_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "sincpt" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out22_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out22_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            sincpt_c(
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                str4,
                str5,
                str6,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3,
                out11_buffer + i,
                out22_buffer + i * 3,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void sphcyl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "sphcyl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            sphcyl_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void sphlat_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "sphlat" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            sphlat_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void sphrec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "sphrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            sphrec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void spkacs_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        SpiceInt k2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "spkacs" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkacs_c(
                k1,
                in11[i],
                str1,
                str2,
                k2,
                out21_buffer + i * 6,
                out11_buffer + i,
                out12_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void spkapo_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkapo" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkapo_c(
                k1,
                in11[i % in11_dim1],
                str1,
                in21 + (i % in21_dim1) * in21_dim2,
                str2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkapp_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkapp" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkapp_c(
                k1,
                in11[i % in11_dim1],
                str1,
                in21 + (i % in21_dim1) * in21_dim2,
                str2,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkaps_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "spkaps" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkaps_c(
                k1,
                in11[i % in11_dim1],
                str1,
                str2,
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 6,
                out11_buffer + i,
                out12_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_spkcov_c(
        ConstSpiceChar *spk,
        SpiceInt       idcode,
        SpiceDouble    cover[WINDOWS][2], int *intervals)
    {
        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        spkcov_c(spk, idcode, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(cover[j][0]), &(cover[j][1]));
        }
    }


    void spkez_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        SpiceInt k2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkez" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkez_c(
                k1,
                in11[i],
                str1,
                str2,
                k2,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkezp_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        SpiceInt k2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkezp" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkezp_c(
                k1,
                in11[i],
                str1,
                str2,
                k2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkezr_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkezr" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkezr_c(
                str1,
                in11[i],
                str2,
                str3,
                str4,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkgeo_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        SpiceInt k2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkgeo" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkgeo_c(
                k1,
                in11[i],
                str1,
                k2,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkgps_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        SpiceInt k2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkgps" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkgps_c(
                k1,
                in11[i],
                str1,
                k2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkltc_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "spkltc" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkltc_c(
                k1,
                in11[i % in11_dim1],
                str1,
                str2,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 6,
                out11_buffer + i,
                out12_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_spkobj_c(
        ConstSpiceChar *spk,
        SpiceInt ids[MAXIDS], int *bodies)
    {
        int j;
        SPICEINT_CELL(cells, MAXIDS);

        scard_c(0, &cells);
        spkobj_c(spk, &cells);

        *bodies = card_c(&cells);
        for (j = 0; j < *bodies; j++) {
            ids[j] = SPICE_CELL_ELEM_I(&cells, j);
        }
    }


    void spkpos_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkpos" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkpos_c(
                str1,
                in11[i],
                str2,
                str3,
                str4,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkssb_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "spkssb" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            spkssb_c(
                k1,
                in11[i],
                str1,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_srfnrm_c(
        ConstSpiceChar *method,
        ConstSpiceChar *target,
        SpiceDouble    et,
        ConstSpiceChar *fixref,
        SpiceInt npts, ConstSpiceDouble srfpts[][3],
        SpiceDouble **normls, int *dim1, int *dim2)
    {
        *normls = NULL;
        *dim1 = 0;
        *dim2 = 3;

        SpiceDouble *result = my_malloc(npts * 3, "srfnrm");
        if (!result) return;

        srfnrm_c(method, target, et, fixref, npts, srfpts, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *normls = result;
        *dim1 = npts;
        *dim2 = 3;
    }


    void srfrec_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "srfrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            srfrec_c(
                k1,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void srfxpt_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "srfxpt" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out22_buffer = out12_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out22_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            free(out12_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            srfxpt_c(
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                str4,
                str5,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3,
                out11_buffer + i,
                out12_buffer + i,
                out22_buffer + i * 3,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_stcf01(
        ConstSpiceChar *catnam,
        SpiceDouble    westra,
        SpiceDouble    eastra,
        SpiceDouble    sthdec,
        SpiceDouble    nthdec,
        SpiceInt       *nstars)
    {
/*
* Original F2C arguments:
*   int stcf01_(char *catnam, doublereal *westra, doublereal *
*               eastra, doublereal *sthdec, doublereal *nthdec, integer *nstars,
*               ftnlen catnam_len)
*
*
*/

        stcf01_(catnam, &westra, &eastra, &sthdec, &nthdec,
                nstars, (int) strlen(catnam));
    }


   void my_stcg01(
        SpiceInt      index,
        SpiceDouble   *ra,
        SpiceDouble   *dec,
        SpiceDouble   *rasig,
        SpiceDouble   *decsig,
        SpiceInt      *catnum,
        SpiceChar     sptype[20],
        SpiceDouble   *vmag)
    {

/*
* Original F2C arguments:
*   int stcg01_(integer *index, doublereal *ra, doublereal *dec,
*               doublereal *rasig, doublereal *decsig, integer *catnum,
*               char *sptype, doublereal *vmag, ftnlen sptype_len)
*/

        int index_plus_one = index + 1;
        stcg01_(&index_plus_one, ra, dec, rasig, decsig, catnum, sptype,
                vmag, 20);

        char *s = sptype+19;
        while (s >= sptype && *s == ' ') s--; /* Convert FORTRAN->C string */
        s[1] = '\0';
    }


    void my_stcl01 (
        ConstSpiceChar *catfnm,
        SpiceChar      tabnam[NAMELEN],
        SpiceInt       *handle)
    {

/*
* Original F2C arguments:
*   int stcl01_(char *catfnm, char *tabnam, integer *handle,
*               ftnlen catfnm_len, ftnlen tabnam_len)
*/

        stcl01_(catfnm, tabnam, handle, (int) strlen(catfnm), NAMELEN);

        char *s = tabnam + NAMELEN - 1;
        while (s >= tabnam && *s == ' ') s--; /* Convert FORTRAN->C string */
        s[1] = '\0';
    }


    void stelab_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "stelab" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            stelab_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void stlabx_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "stlabx" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            stlabx_(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_stpool_c(
        ConstSpiceChar *item,
        SpiceInt       nth,
        ConstSpiceChar *contin,
        SpiceInt lenout, SpiceChar string[MESSAGELEN],
        SpiceBoolean   *found)
    {
        SpiceInt size = 0;

        stpool_c(item, nth, contin,
                 lenout, string, &size, found);
    }


    void subpnt_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "subpnt" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out22_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out22_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            subpnt_c(
                str1,
                str2,
                in11[i],
                str3,
                str4,
                str5,
                out21_buffer + i * 3,
                out11_buffer + i,
                out22_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void subpt_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "subpt" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            subpt_c(
                str1,
                str2,
                in11[i],
                str3,
                str4,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void subslr_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2) {
        char *my_name = "subslr" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out22_buffer = out11_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out22_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            subslr_c(
                str1,
                str2,
                in11[i],
                str3,
                str4,
                str5,
                out21_buffer + i * 3,
                out11_buffer + i,
                out22_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
    }


    void subsol_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "subsol" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            subsol_c(
                str1,
                str2,
                in11[i],
                str3,
                str4,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void surfpt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "surfpt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceBoolean *bool1_buffer = out21_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            surfpt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void surfpv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "surfpv" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceBoolean *bool1_buffer = out21_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            surfpv_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 6,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void sxform_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "sxform" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            sxform_c(
                str1,
                str2,
                in11[i],
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_termpt_c(
        ConstSpiceChar   *method,
        ConstSpiceChar   *ilusrc,
        ConstSpiceChar   *target,
        SpiceDouble      et,
        ConstSpiceChar   *fixref,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *corloc,
        ConstSpiceChar   *obsrvr,
        ConstSpiceDouble refvec[3],
        SpiceDouble      rolstp,
        SpiceInt         ncuts,
        SpiceDouble      schstp,
        SpiceDouble      soltol,
        SpiceInt         maxn,
        SpiceInt    **npts,   SpiceInt *ndim1,
        SpiceDouble **points, int      *pdim1, int *pdim2,
        SpiceDouble **epochs, int      *edim1,
        SpiceDouble **trmvcs, int      *tdim1, int *tdim2)
    {
        *npts = NULL;
        *ndim1 = 0;

        *points = NULL;
        *pdim1 = 0;
        *pdim2 = 3;

        *epochs = NULL;
        *edim1 = 0;

        *trmvcs = NULL;
        *tdim1 = 0;
        *tdim2 = 3;

        SpiceInt    *npts1 = my_int_malloc(maxn,   "termpt");
        SpiceDouble *points1 = my_malloc(maxn * 3, "termpt");
        SpiceDouble *epochs1 = my_malloc(maxn,     "termpt");
        SpiceDouble *trmvcs1 = my_malloc(maxn * 3, "termpt");

        if (!trmvcs1) {
            free(npts1);
            free(points1);
            free(epochs1);
            free(trmvcs1);
            return;
        }

        termpt_c(method, ilusrc, target, et, fixref, abcorr, corloc, obsrvr,
                 refvec, rolstp, ncuts, schstp, soltol, maxn,
                 npts1, points1, epochs1, trmvcs1);

        if (failed_c()) {
            free(npts1);
            free(points1);
            free(epochs1);
            free(trmvcs1);
            return;
        }

        *npts = npts1;
        *ndim1 = maxn;

        *points = points1;
        *pdim1 = maxn;
        *pdim2 = 3;

        *epochs = epochs1;
        *edim1 = maxn;

        *trmvcs = trmvcs1;
        *tdim1 = maxn;
        *tdim2 = 3;
    }


    void tipbod_vector(
        ConstSpiceChar *str1,
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "tipbod" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            tipbod_c(
                str1,
                k1,
                in11[i],
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void tisbod_vector(
        ConstSpiceChar *str1,
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "tisbod" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            tisbod_c(
                str1,
                k1,
                in11[i],
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_tparse_c(
        ConstSpiceChar *string,
        SpiceDouble *sp2000,
        SpiceInt lenout, SpiceChar errmsg[MESSAGELEN])
    {
        tparse_c(string, lenout, sp2000, errmsg);
    }


    void my_tpictr_c(
        ConstSpiceChar *sample,
        SpiceInt lenout, SpiceChar pictur[TIMELEN],
        SpiceBoolean *ok,
        SpiceInt lenerr, SpiceChar errmsg[MESSAGELEN])
    {
        tpictr_c(sample, lenout, lenerr, pictur, ok, errmsg);
    }


    void trace_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "trace" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = trace_c(
                in31 + (i) * in31_dim2 * in31_dim3);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void twovec_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceInt k1,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceInt k2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "twovec" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            twovec_c(
                in21 + (i % in21_dim1) * in21_dim2,
                k1,
                in22 + (i % in22_dim1) * in22_dim2,
                k2,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void ucrss_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "ucrss" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            ucrss_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void unitim_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "unitim" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = unitim_c(
                in11[i],
                str1,
                str2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void unorm_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "unorm" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            unorm_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_unormg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble **vector, int      *nd2,
        SpiceDouble    *vmag)
    {
        *vector = NULL;
        *nd2 = 0;

        SpiceDouble *result = my_malloc(ndim, "unormg");
        if (!result) return;

        unormg_c(v1, ndim, result, vmag);

        if (failed_c()) {
            free(result);
            return;
        }

        *vector = result;
        *nd2 = ndim;
    }

    void my_unormg_nomalloc(ConstSpiceDouble *v1, SpiceInt ndim,
                            SpiceDouble  *vector, int      *nd2,
                            SpiceDouble    *vmag)
    {
        unormg_c(v1, ndim, vector, vmag);
        *nd2 = ndim;
    }


    void unormg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "unormg" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in21_dim2;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * in21_dim2, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_unormg_nomalloc(
                in21 + (i) * in21_dim2, in21_dim2,
                out21_buffer + i * in21_dim2, out21_dim2,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vadd_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vadd" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vadd_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vaddg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int      nd2,
        SpiceDouble     **v3, int     *nd3)
    {
        SpiceDouble *result = NULL;

        *v3 = NULL;
        *nd3 = 0;

        if (!my_assert_eq(ndim, nd2, "vaddg",
            "Vector dimension mismatch in vaddg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        result = my_malloc(ndim, "vaddg");
        if (!result) return;

        vaddg_c(v1, v2, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v3 = result;
        *nd3 = ndim;
    }

    void my_vaddg_nomalloc(ConstSpiceDouble *v1, SpiceInt ndim,
                    ConstSpiceDouble *v2, int      nd2,
                    SpiceDouble      *v3, int     *nd3)
    {
        if (!my_assert_eq(ndim, nd2, "vaddg",
            "Vector dimension mismatch in vaddg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        vaddg_c(v1, v2, ndim, v3);
        *nd3 = ndim;
    }


    void vaddg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vaddg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in22_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in22_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vaddg_nomalloc(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                out21_buffer + i * in22_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vcrss_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vcrss" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vcrss_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vdist_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vdist" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vdist_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceDouble my_vdistg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int nd2)
    {
        if (!my_assert_eq(ndim, nd2, "vdistg",
            "Vector dimension mismatch in vdistg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return NAN;

        return vdistg_c(v1, v2, ndim);
    }


    void vdistg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vdistg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_vdistg_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vdot_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vdot" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vdot_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceDouble my_vdotg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int nd2)
    {
        if (!my_assert_eq(ndim, nd2, "vdotg",
            "Vector dimension mismatch in vdotg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return NAN;

        return vdotg_c(v1, v2, ndim);
    }


    void vdotg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vdotg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_vdotg_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vequ_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vequ" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vequ_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vequg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble     **v2, int      *nd2)
    {
        *v2 = NULL;
        *nd2 = 0;

        SpiceDouble *result = my_malloc(ndim, "vequg");
        if (!result) return;

        vequg_c(v1, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v2 = result;
        *nd2 = ndim;
    }

    void my_vequg_nomalloc(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble      *v2, int      *nd2)
    {
        vequg_c(v1, ndim, v2);
        *nd2 = ndim;
    }


    void vequg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vequg" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in21_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in21_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vequg_nomalloc(
                in21 + (i) * in21_dim2, in21_dim2,
                out21_buffer + i * in21_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vhat_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vhat" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vhat_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vhatg_c(
        ConstSpiceDouble  *v1, SpiceInt ndim,
        SpiceDouble      **v2, int      *nd2)
    {
        *v2 = NULL;
        *nd2 = 0;

        SpiceDouble *result = my_malloc(ndim, "vhatg");
        if (!result) return;

        vhatg_c(v1, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v2 = result;
        *nd2 = ndim;
    }

    void my_vhatg_nomalloc(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble      *v2, int      *nd2)
    {
        vhatg_c(v1, ndim, v2);
        *nd2 = ndim;
    }


    void vhatg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vhatg" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in21_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in21_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vhatg_nomalloc(
                in21 + (i) * in21_dim2, in21_dim2,
                out21_buffer + i * in21_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vlcom3_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vlcom3" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vlcom3_c(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in12[i % in12_dim1],
                in22 + (i % in22_dim1) * in22_dim2,
                in13[i % in13_dim1],
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vlcom_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vlcom" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vlcom_c(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in12[i % in12_dim1],
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vlcomg_c(
        SpiceDouble       a,
        ConstSpiceDouble *v1, SpiceInt n,
        SpiceDouble       b,
        ConstSpiceDouble *v2, int nd2,
        SpiceDouble     **v3, int *nd3)
    {
        *v3 = NULL;
        *nd3 = 0;

        if (!my_assert_eq(n, nd2, "vlcomg",
            "Vector dimension mismatch in vlcomg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        SpiceDouble *result = my_malloc(n, "vlcomg");
        if (!result) return;

        vlcomg_c(n, a, v1, b, v2, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v3 = result;
        *nd3 = n;
    }

    void my_vlcomg_nomalloc(
        SpiceDouble       a,
        ConstSpiceDouble *v1, SpiceInt  n,
        SpiceDouble       b,
        ConstSpiceDouble *v2, int nd2,
        SpiceDouble      *v3, int *nd3)
    {
        if (!my_assert_eq(n, nd2, "vlcomg",
            "Vector dimension mismatch in vlcomg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        vlcomg_c(n, a, v1, b, v2, v3);
        *nd3 = n;
    }


    void vlcomg_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vlcomg" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in22_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in22_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vlcomg_nomalloc(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in12[i % in12_dim1],
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                out21_buffer + i * in22_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vminug_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble     **v2, int      *nd2)
    {
        *v2 = NULL;
        *nd2 = 0;

        SpiceDouble *result = my_malloc(ndim, "vminug");
        if (!result) return;

        vminug_c(v1, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v2 = result;
        *nd2 = ndim;
    }

    void my_vminug_nomalloc(
        ConstSpiceDouble *v1, SpiceInt ndim,
        SpiceDouble      *v2, int      *nd2)
    {
        vminug_c(v1, ndim, v2);
        *nd2 = ndim;
    }


    void vminug_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vminug" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in21_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in21_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vminug_nomalloc(
                in21 + (i) * in21_dim2, in21_dim2,
                out21_buffer + i * in21_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vminus_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vminus" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vminus_c(
                in21 + (i) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vnorm_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vnorm" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vnorm_c(
                in21 + (i) * in21_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vnormg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vnormg" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vnormg_c(
                in21 + (i) * in21_dim2, in21_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vpack_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vpack" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vpack_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vperp_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vperp" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vperp_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vprjp_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vprjp" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vprjp_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vprjpi_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "vprjpi" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceBoolean *bool1_buffer = out21_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            vprjpi_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * 3,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void vproj_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vproj" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vproj_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vrel_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vrel" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vrel_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceDouble my_vrelg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int nd2)
    {
        if (!my_assert_eq(ndim, nd2, "vrelg",
            "Vector dimension mismatch in vrelg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return NAN;

        return vrelg_c(v1, v2, ndim);
    }


    void vrelg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vrelg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_vrelg_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vrotv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vrotv" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vrotv_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vscl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vscl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vscl_c(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vsclg_c(
        SpiceDouble      s,
        ConstSpiceDouble *v1, SpiceInt  ndim,
        SpiceDouble     **v2, int *nd2)
    {
        *v2 = NULL;
        *nd2 = 0;

        SpiceDouble *result = my_malloc(ndim, "vsclg");
        if (!result) return;

        vsclg_c(s, v1, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v2 = result;
        *nd2 = ndim;
    }

    void my_vsclg_nomalloc(
        SpiceDouble s,
        ConstSpiceDouble   *v1, SpiceInt  ndim,
        SpiceDouble        *v2, int       *nd2)
    {
        vsclg_c(s, v1, ndim, v2);
        *nd2 = ndim;
    }


    void vsclg_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vsclg" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in21_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in21_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vsclg_nomalloc(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                out21_buffer + i * in21_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vsep_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vsep" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vsep_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceDouble my_vsepg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int nd2)
    {
        if (!my_assert_eq(ndim, nd2, "vsepg",
            "Vector dimension mismatch in vsepg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return NAN;

        return vsepg_c(v1, v2, ndim);
    }


    void vsepg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vsepg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_vsepg_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vsub_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vsub" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            vsub_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_vsubg_c(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int      nd2,
        SpiceDouble     **v3, int     *nd3)
    {
        *v3 = NULL;
        *nd3 = 0;

        if (!my_assert_eq(ndim, nd2, "vsubg",
            "Vector dimension mismatch in vsubg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        SpiceDouble *result = my_malloc(ndim, "vsubg");
        if (!result) return;

        vsubg_c(v1, v2, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *v3 = result;
        *nd3 = ndim;
    }

    void my_vsubg_nomalloc(
        ConstSpiceDouble *v1, SpiceInt ndim,
        ConstSpiceDouble *v2, int      nd2,
        SpiceDouble      *v3, int     *nd3)
    {
        if (!my_assert_eq(ndim, nd2, "vsubg",
            "Vector dimension mismatch in vsubg: "
            "vector 1 dimension = #; vector 2 dimension = #")) return;

        vsubg_c(v1, v2, ndim, v3);
        *nd3 = ndim;
    }


    void vsubg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vsubg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in22_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in22_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vsubg_nomalloc(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                out21_buffer + i * in22_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void vtmv_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vtmv" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in31_dim1) maxdim = in31_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = vtmv_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in22 + (i % in22_dim1) * in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceDouble my_vtmvg_c(
        SpiceDouble *v1, int nrow1,
        SpiceDouble *matrix, SpiceInt nrow, SpiceInt ncol,
        SpiceDouble *v2, int ncol2)
    {
        if (!my_assert_eq(nrow1, nrow, "vtmvg",
            "Array dimension mismatch in vtmvg: "
            "vector 1 dimension = #; matrix rows = #")) return NAN;

        if (!my_assert_eq(ncol2, ncol, "vtmvg",
            "Array dimension mismatch in vtmvg: "
            "column rows = #; vector 2 dimension = #")) return NAN;

        return vtmvg_c(v1, matrix, v2, nrow, ncol);
    }


    void vtmvg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "vtmvg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in31_dim1) maxdim = in31_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_vtmvg_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void vupack_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "vupack" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            vupack_c(
                in21 + (i) * in21_dim2,
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void vzero_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "vzero" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceBoolean *bool1_buffer = my_bool_malloc(size, my_name);
        if (!bool1_buffer) return;
        for (int i = 0; i < size; i++) {
            bool1_buffer[i] = vzero_c(
                in21 + (i) * in21_dim2);
        }

        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void vzerog_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "vzerog" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceBoolean *bool1_buffer = my_bool_malloc(size, my_name);
        if (!bool1_buffer) return;
        for (int i = 0; i < size; i++) {
            bool1_buffer[i] = vzerog_c(
                in21 + (i) * in21_dim2, in21_dim2);
        }

        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void xf2eul_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "xf2eul" "_vector";

        int maxdim = in31_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceBoolean *bool1_buffer = out21_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            xf2eul_c(
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 6,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void xf2rav_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "xf2rav" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;
        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        SpiceDouble *out21_buffer = out31_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out21_buffer) {
            free(out31_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            xf2rav_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 3 * 3,
                out21_buffer + i * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void xfmsta_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "xfmsta" "_vector";

        int maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            xfmsta_c(
                in21 + (i) * in21_dim2,
                str1,
                str2,
                str3,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void xpose6_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "xpose6" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            xpose6_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void xpose_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "xpose" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            xpose_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_xposeg_c(
        ConstSpiceDouble *matrix, SpiceInt nrow, SpiceInt  ncol,
        SpiceDouble     **xposem, int    *nrow1,     int *nc1)
    {
        *xposem = NULL;
        *nrow1 = 0;
        *nc1 = 0;

        SpiceDouble *result = my_malloc(nrow * ncol, "xposeg");
        if (!result) return;

        xposeg_c(matrix, nrow, ncol, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *xposem = result;
        *nrow1 = ncol;
        *nc1 = nrow;
    }

    void my_xposeg_nomalloc(
        ConstSpiceDouble *matrix, SpiceInt nrow, SpiceInt  ncol,
        SpiceDouble      *xposem, int    *nrow1,     int *nc1)
    {
        xposeg_c(matrix, nrow, ncol, xposem);
        *nrow1 = ncol;
        *nc1 = nrow;
    }


    void xposeg_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "xposeg" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = in31_dim3; *out31_dim3 = in31_dim2;

        SpiceDouble *out31_buffer = my_malloc(size * in31_dim3 * in31_dim2, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            my_xposeg_nomalloc(
                in31 + (i) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                out31_buffer + i * in31_dim3 * in31_dim2, out31_dim2, out31_dim3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void azlcpo_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        SpiceBoolean b1,
        SpiceBoolean b2,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "azlcpo" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            azlcpo_c(
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                b1,
                b2,
                in21 + (i % in21_dim1) * in21_dim2,
                str4,
                str5,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void azlrec_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceBoolean b1,
        SpiceBoolean b2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "azlrec" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            azlrec_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                b1,
                b2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void brcktd_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "brcktd" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = brcktd_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1]);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    SpiceInt my_bsrchd_vector(
        SpiceDouble value,
        ConstSpiceDouble *array, SpiceInt ndim)
    {
        return bsrchd_c(value, ndim, array);
    }


    void bsrchd_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceInt **int1, int *int1_dim1) {
        char *my_name = "bsrchd" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *int1 = NULL; *int1_dim1 = 0;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        if (!int1_buffer) return;
        for (int i = 0; i < size; i++) {
            int1_buffer[i] = my_bsrchd_vector(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
    }


    void my_chbder_c(
        ConstSpiceDouble *cp, SpiceInt deg_plus_1,
        SpiceDouble      x2s[2],
        SpiceDouble      x,
        SpiceInt         nderiv,
        SpiceDouble      **dpdxs, SpiceInt *n)
    {

        int nderiv_plus_1 = nderiv + 1;

        *dpdxs = NULL;
        *n = 0;

        SpiceDouble *result = my_malloc(nderiv_plus_1, "chbder");
        SpiceDouble *partdp = my_malloc(3 * nderiv_plus_1, "chbder");
        if (!partdp) {
            free(result);
            free(partdp);
            return;
        }

        chbder_c(cp, deg_plus_1 - 1, x2s, x, nderiv, partdp, result);
        free(partdp);

        if (failed_c()) {
            free(result);
            return;
        }

        *dpdxs = result;
        *n = nderiv_plus_1;
    }

    // This function doesn't fit any of our vectorization templates, because
    // the rightmost dimension of the returned axis is variable.

    void chbder_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble x2s[2],
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceInt nderiv,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2)
    {
        char *my_name = "chbder_vector";

        // in21 is cp
        // in12 is x
        // out21 is dpdxs

        int nderiv_plus_1 = nderiv + 1;
        int degp = in21_dim1 - 1;

        *out21 = NULL;
        *out21_dim1 = 0;
        *out21_dim2 = nderiv_plus_1;

        int maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        SpiceDouble *out21_buffer = my_malloc(size * nderiv_plus_1, my_name);
        if (!out21_buffer) return;

        SpiceDouble *partdp = my_malloc(3 * nderiv_plus_1, my_name);
        if (!partdp) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            chbder_c(
                in21 + (i % in21_dim1) * in21_dim2, degp,
                x2s,
                in12[i % in12_dim1],
                nderiv,
                partdp,
                out21_buffer + i * nderiv_plus_1
            );
        }

        free(partdp);

        if (failed_c()) {
            free(out21_buffer);
            return;
        }

        *out21 = out21_buffer;
        *out21_dim1 = maxdim;
        *out21_dim2 = nderiv_plus_1;
    }


    void my_chbigr_c(
        ConstSpiceDouble *cp, SpiceInt ncp,
        ConstSpiceDouble x2s[2],
        SpiceDouble      x,
        SpiceDouble      *p,
        SpiceDouble      *itgrlp)
    {
        chbigr_c(ncp - 1, cp, x2s, x, p, itgrlp);
    }


    void chbigr_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "chbigr" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_chbigr_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_chbint_c(
        ConstSpiceDouble *cp, SpiceInt ncp,
        ConstSpiceDouble x2s[2],
        SpiceDouble      x,
        SpiceDouble      *p,
        SpiceDouble      *dpdx)
    {
        chbint_c(cp, ncp - 1, x2s, x, p, dpdx);
    }


    void chbint_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "chbint" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_chbint_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_chbval_c(
        ConstSpiceDouble *cp, SpiceInt ncp,
        ConstSpiceDouble x2s[2],
        SpiceDouble      x,
        SpiceDouble      *p)
    {
        chbval_c(cp, ncp - 1, x2s, x, p);
    }


    void chbval_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "chbval" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            my_chbval_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in11[i % in11_dim1],
                out11_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void ckfrot_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceInt **int1, int *int1_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "ckfrot" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in31_dim1) maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *int1 = NULL; *int1_dim1 = 0;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        SpiceBoolean *bool1_buffer = int1_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(int1_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ckfrot_c(
                k1,
                in11[i % in11_dim1],
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                int1_buffer + i,
                bool1_buffer + i);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void ckfxfm_vector(
        SpiceInt k1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceInt **int1, int *int1_dim1,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "ckfxfm" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in31_dim1) maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *int1 = NULL; *int1_dim1 = 0;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceInt *int1_buffer = my_int_malloc(size, my_name);
        SpiceBoolean *bool1_buffer = int1_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(int1_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            ckfxfm_c(
                k1,
                in11[i % in11_dim1],
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3,
                int1_buffer + i,
                bool1_buffer + i);
        }

        *int1 = int1_buffer; *int1_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_ckgr03_c(
        SpiceInt         handle,
        ConstSpiceDouble descr[5],
        SpiceInt         recno,
        SpiceDouble      **record, int *size)
    {
        SpiceDouble dcd[2];
        SpiceInt    icd[6];
        dafus_c(descr, 2, 6, dcd, icd);

        int avseg = (icd[3] == 1);
        if (avseg) {
            *size = 8;
        } else {
            *size = 5;
        }

        SpiceDouble *buffer = my_malloc(*size, "ckgr03");
        if (!buffer) {
            *size = 0;
            return;
        }

        ckgr03_c(handle, descr, recno, buffer);

        if (failed_c()) {
            free(buffer);
            *size = 0;
            *record = NULL;
        } else {
            *record = buffer;
        }
    }


    void my_ckw05_c(
        SpiceInt         handle,
        ConstSpiceChar   *subtyp,
        SpiceInt         degree,
        SpiceDouble      begtim,
        SpiceDouble      endtim,
        SpiceInt         inst,
        ConstSpiceChar   *ref,
        SpiceBoolean     avflag,
        ConstSpiceChar   *segid,
        SpiceInt         n, ConstSpiceDouble *sclkdp,
        ConstSpiceDouble *packts,
        SpiceDouble      rate,
        SpiceInt         nints,
        ConstSpiceDouble *starts)
    {
        SpiceCK05Subtype subtyp_;
        if (strcmp(subtyp, "C05TP0") == 0) {
            subtyp_ = C05TP0;
        } else if (strcmp(subtyp, "C05TP1") == 0) {
            subtyp_ = C05TP1;
        } else if (strcmp(subtyp, "C05TP2") == 0) {
            subtyp_ = C05TP2;
        } else if (strcmp(subtyp, "C05TP3") == 0) {
            subtyp_ = C05TP3;
        } else {
            chkin_c("ckw05");
            setmsg_c("subtyp value must be one of {\"C05TP0\", \"C05TP1\", \"C05TP2\", \"C05TP3\"}");
            sigerr_c("SPICE(SPICE(INVALIDARGUMENT)");
            chkout_c("ckw05");
            return;
        }

        ckw05_c(handle, subtyp_, degree, begtim, endtim, inst, ref, avflag, segid,
                n, sclkdp, packts, rate, nints, starts);
    }


    void my_dafgsr_c(
        SpiceInt     handle,
        SpiceInt     recno,
        SpiceInt     begin,
        SpiceInt     end,
        SpiceDouble  data[DAFSIZE], int *size,
        SpiceBoolean *found)
    {
        dafgsr_c(handle, recno, begin, end, data, found);
        if (*found) {
            *size = end - begin + 1;
        } else {
           *size = 0;
        }
    }


    void my_dafps_c(
        SpiceInt nd, ConstSpiceDouble *dc,
        SpiceInt ni, ConstSpiceInt *ic,
        SpiceDouble sum[DAFSIZE], int *nsum)
    {
        dafps_c(nd, ni, dc, ic, sum);
        *nsum = nd + (ni + 1)/2 + 1;
    }


    void my_dafrfr_c(
        SpiceInt handle,
        SpiceInt *nd,
        SpiceInt *ni,
        SpiceInt ifnlen,  SpiceChar ifname[FILELEN],
        SpiceInt *fward,
        SpiceInt *bward,
        SpiceInt *free)
    {
        dafrfr_c(handle, ifnlen, nd, ni, ifname, fward, bward, free);
    }





    void my_dasrdd_c(
        SpiceInt    handle,
        SpiceInt    first,
        SpiceInt    last,
        SpiceDouble data[MAXRECS], int *size)
    {
        if (!my_assert_ge(MAXRECS, last - first + 1, "dasrdd",
            "Array dimension is too small: "
            "provided = #; required = #")) return;

        dasrdd_c(handle, first, last, data);
        *size = last - first + 1;
    }


    void my_dasrdi_c(
        SpiceInt handle,
        SpiceInt first,
        SpiceInt last,
        SpiceInt data[MAXRECS], int *size)
    {
        if (!my_assert_ge(MAXRECS, last - first + 1, "dasrdi",
            "Array dimension is too small: "
            "provided = #; required = #")) return;

        dasrdi_c(handle, first, last, data);
        *size = last - first + 1;
    }


    void my_dasrfr_c(
        SpiceInt  handle,
        SpiceInt  idwlen, SpiceChar idword[10],
        SpiceInt  ifnlen, SpiceChar ifname[61],
        SpiceInt  *nresvr,
        SpiceInt  *nresvc,
        SpiceInt  *ncomr,
        SpiceInt  *ncomc)
    {
        dasrfr_c(handle, idwlen, ifnlen, idword, ifname,
                 nresvr, nresvc, ncomr, ncomc);
    }


    void dazldr_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceBoolean b1,
        SpiceBoolean b2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "dazldr" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            dazldr_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                b1,
                b2,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void dnearp_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceBoolean **bool1, int *bool1_dim1) {
        char *my_name = "dnearp" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 2;
        *bool1 = NULL; *bool1_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out22_buffer = out21_buffer ? my_malloc(size * 2, my_name) : NULL;
        SpiceBoolean *bool1_buffer = out22_buffer ? my_bool_malloc(size, my_name) : NULL;
        if (!bool1_buffer) {
            free(out21_buffer);
            free(out22_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            dnearp_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 6,
                out22_buffer + i * 2,
                bool1_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *bool1 = bool1_buffer; *bool1_dim1 = maxdim;
    }


    void my_dp2hx_c(
        SpiceDouble number,
        SpiceChar   hxstr[256])
    {
        SpiceInt hxssiz;

        dp2hx_c(number, 256, hxstr, &hxssiz);
        hxstr[hxssiz] = 0;
    }


    void drdazl_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceBoolean b1,
        SpiceBoolean b2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "drdazl" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 3; *out31_dim3 = 3;

        SpiceDouble *out31_buffer = my_malloc(size * 3 * 3, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            drdazl_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                b1,
                b2,
                out31_buffer + i * 3 * 3);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_dskmi2_c(
        SpiceInt         nv, ConstSpiceDouble vrtces[][3],
        SpiceInt         np, ConstSpiceInt    plates[][3],
        SpiceDouble      finscl,
        SpiceInt         corscl,
        SpiceBoolean     makvtl,
        SpiceDouble      spaixd[SPICE_DSK02_SPADSZ],
        SpiceInt         spaixi[SPICE_DSK02_SPAISZ])
    {
        SpiceInt voxpsz = SPICE_DSK02_MAXVXP;
        SpiceInt voxlsz = SPICE_DSK02_MXNVLS;
        SpiceInt worksz = SPICE_DSK02_MAXCEL;
        SpiceInt spxisz = SPICE_DSK02_SPAISZ;
        SpiceInt work[SPICE_DSK02_MAXCEL][2];

        dskmi2_c(nv, vrtces, np, plates, finscl, corscl, worksz, voxpsz, voxlsz,
                 makvtl, spxisz, work, spaixd, spaixi);
    }


    void my_dskobj_c(
        ConstSpiceChar *dskfnm,
        SpiceInt bodids[MAXIDS], int *count)
    {
        int j;
        SPICEINT_CELL(ids, MAXIDS);

        scard_c(0, &ids);
        dskobj_c(dskfnm, &ids);

        *count = card_c(&ids);
        for (j = 0; j < *count; j++) {
            bodids[j] = SPICE_CELL_ELEM_I(&ids, j);
        }
    }


    void my_dsksrf_c(
        ConstSpiceChar *dskfnm,
        SpiceInt bodyid,
        SpiceInt srfids[MAXIDS], int *count)
    {
        int j;
        SPICEINT_CELL(ids, MAXIDS);

        scard_c(0, &ids);
        dsksrf_c(dskfnm, bodyid, &ids);

        *count = card_c(&ids);
        for (j = 0; j < *count; j++) {
            srfids[j] = SPICE_CELL_ELEM_I(&ids, j);
        }
    }


    void my_dskxsi_c(
        SpiceBoolean     pri,
        ConstSpiceChar   *target,
        SpiceInt         nsurf, ConstSpiceInt srflst[],
        SpiceDouble      et,
        ConstSpiceChar   *fixref,
        ConstSpiceDouble vertex[3],
        ConstSpiceDouble raydir[3],
        SpiceDouble      xpt[3],
        SpiceInt         *handle,
        SpiceInt         dladsc[DLASIZE],
        SpiceDouble      dskdsc[DSKSIZE],
        SpiceDouble      dc[SPICE_DSKXSI_DCSIZE],
        SpiceInt         ic[SPICE_DSKXSI_ICSIZE],
        SpiceBoolean     *found)
    {
        dskxsi_c(pri, target, nsurf, srflst, et, fixref, vertex, raydir,
                 SPICE_DSKXSI_DCSIZE, SPICE_DSKXSI_ICSIZE,
                 xpt, handle, dladsc, dskdsc, dc, ic, found);
    }


    void my_dskxv_c(
        SpiceBoolean   pri,
        ConstSpiceChar *target,
        SpiceInt       nsurf, ConstSpiceInt srflst[],
        SpiceDouble    et,
        ConstSpiceChar *fixref,
        SpiceInt       nrays, ConstSpiceDouble vtxarr[][3],
        SpiceInt       n2,    ConstSpiceDouble dirarr[][3],
        SpiceInt       *n3,   SpiceInt *nv, SpiceDouble **xptarr,
        SpiceInt       *n4,   SpiceBoolean **fndarr)
    {
        *xptarr = NULL;
        *fndarr = NULL;
        *n3 = 0;
        *nv = 3;
        *n4 = 0;

        if (!my_assert_eq(nrays, n2, "dskxv",
            "Array dimension mismatch in dskxv: "
            "vtxarr dimension = #; dirarr dimension = #")) return;

        SpiceBoolean *found = my_malloc(nrays, "dskxv");
        SpiceDouble *vector = my_malloc(nrays * 3, "dskxv");
        if (!vector) {
            free(found);
            found = NULL;
            return;
        }

        dskxv_c(pri, target, nsurf, srflst, et, fixref, nrays,
                vtxarr, dirarr, vector, found);

        if (failed_c()) {
            free(found);
            free(vector);
            return;
        }

        *xptarr = vector;
        *fndarr = found;
        *n3 = nrays;
        *nv = 3;
        *n4 = nrays;
    }


    void ednmpt_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "ednmpt" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            ednmpt_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void edpnt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "edpnt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            edpnt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in13[i % in13_dim1],
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_ekaclc_c(
        SpiceInt          handle,
        SpiceInt          segno,
        ConstSpiceChar    *column,
        SpiceInt          vallen, ConstSpiceChar *cvals,
        ConstSpiceInt     entszs[],
        ConstSpiceBoolean nlflgs[],
        ConstSpiceInt     rcptrs[])
    {
        SpiceInt wkindx[MAXROWS];

        ekaclc_c(handle, segno, column, vallen, cvals, entszs, nlflgs, rcptrs,
                 wkindx);
    }


    void my_ekacld_c(
        SpiceInt          handle,
        SpiceInt          segno,
        ConstSpiceChar    *column,
        ConstSpiceDouble  dvals[],
        ConstSpiceInt     entszs[],
        ConstSpiceBoolean nlflgs[],
        ConstSpiceInt     rcptrs[])
    {
        SpiceInt wkindx[MAXROWS];

        ekacld_c(handle, segno, column, dvals, entszs, nlflgs, rcptrs,
                 wkindx);
    }


    void my_ekacli_c(
        SpiceInt          handle,
        SpiceInt          segno,
        ConstSpiceChar    *column,
        ConstSpiceInt     ivals[],
        ConstSpiceInt     entszs[],
        ConstSpiceBoolean nlflgs[],
        ConstSpiceInt     rcptrs[])
    {
        SpiceInt wkindx[MAXROWS];

        ekacli_c(handle, segno, column, ivals, entszs, nlflgs, rcptrs,
                 wkindx);
    }


    void my_ekcii_c(
        ConstSpiceChar *table,
        SpiceInt       cindex,
        SpiceInt       collen, SpiceChar column[NAMELEN],
        SpiceInt       *cclass,
        SpiceInt       *dtype,
        SpiceInt       *strlen,
        SpiceInt       *size,
        SpiceBoolean   *indexd,
        SpiceBoolean   *nullok)
    {
        SpiceEKAttDsc attdsc;

        ekcii_c(table, cindex, collen, column, &attdsc);

        *cclass = attdsc.cclass;
        *dtype  = (int) attdsc.dtype;
        *strlen = attdsc.strlen;
        *size   = attdsc.size;
        *indexd = attdsc.indexd;
        *nullok = attdsc.nullok;
    }


    void my_ekfind_c(
        ConstSpiceChar *query,
        SpiceInt       *nmrows,
        SpiceBoolean   *error,
        SpiceChar      errmsg[MESSAGELEN])
    {
        ekfind_c(query, MESSAGELEN, nmrows, error, errmsg);
    }


    void my_ekifld_c(
        SpiceInt       handle,
        ConstSpiceChar *tabnam,
        SpiceInt       nrows,
        SpiceInt       ncols, SpiceInt cnamln, ConstSpiceChar *cnames,
        SpiceInt       declen, ConstSpiceChar *decls,
        SpiceInt       *segno,
        SpiceInt       *nrows1, SpiceInt rcptrs[MAXROWS])
    {
        ekifld_c(handle, tabnam, ncols, nrows, cnamln, cnames, declen, decls,
                 segno, rcptrs);
    }


    void my_ekpsel_c(
        ConstSpiceChar *query,
        SpiceInt       *n,
        SpiceInt       xbegs[CLAUSES],
        SpiceInt       xends[CLAUSES],  int *n1,
        SpiceInt       xtypes[CLAUSES], int *n2,
        SpiceInt       xclass[CLAUSES], int *n3,
        char           tabs[CLAUSES][NAMELEN], int *n4,
        char           cols[CLAUSES][NAMELEN], int *n5,
        SpiceBoolean   *error,
        SpiceChar      errmsg[MESSAGELEN])
    {
        SpiceEKDataType xtypes_[CLAUSES];   // 0 = char, 1 = float, 2 = int, 3 = time
        SpiceEKExprClass xclass_[CLAUSES];  // SPICE_EK_EXP_COL = 0 for column
                                            // SPICE_EK_EXP_FUNC = 1 for simple function
                                            // SPICE_EK_EXP_EXPR = 2 for general expression

        ekpsel_c(query, MESSAGELEN, NAMELEN, NAMELEN, n, xbegs, xends,
                 xtypes_, xclass_, tabs, cols, error, errmsg);
        if (*error) {
            *n1 = 0;
            *n2 = 0;
            *n3 = 0;
            *n4 = 0;
            *n5 = 0;
        } else {
            *n1 = *n;
            *n2 = *n;
            *n3 = *n;
            *n4 = *n;
            *n5 = *n;

            for (int j = 0; j < *n; j++) {
                xtypes[j] = (SpiceInt) xtypes_[j];
                xclass[j] = (SpiceInt) xclass_[j];
            }
        }
    }


    void my_ekssum_c(
        SpiceInt     handle,
        SpiceInt     segno,
        SpiceChar    tabnam[NAMELEN], int *nrows,
        SpiceInt     *ncols,
        SpiceChar    cnames[SPICE_EK_MXCLSG][NAMELEN], int *n1,
        SpiceInt     cclass[SPICE_EK_MXCLSG], int *n2,
        SpiceInt      dtype[SPICE_EK_MXCLSG], int *n3,
        SpiceInt      strln[SPICE_EK_MXCLSG], int *n4,
        SpiceInt       size[SPICE_EK_MXCLSG], int *n5,
        SpiceBoolean indexd[SPICE_EK_MXCLSG], int *n6,
        SpiceBoolean nullok[SPICE_EK_MXCLSG], int *n7)
    {
        SpiceEKSegSum segsum;

        ekssum_c(handle, segno, &segsum);

        strncpy(tabnam, segsum.tabnam, SPICE_EK_TSTRLN);
        *nrows = segsum.nrows;
        *ncols = segsum.ncols;

        for (int k = 0; k < *nrows; k++) {
            strncpy(&(cnames[k]), &(segsum.cnames[k]), SPICE_EK_CSTRLN);
            cclass[k] = (SpiceInt) segsum.cdescrs[k].cclass;
            dtype[k]  = (SpiceInt) segsum.cdescrs[k].dtype;
            strln[k]  = segsum.cdescrs[k].strlen;
            size[k]   = segsum.cdescrs[k].size;
            indexd[k] = segsum.cdescrs[k].indexd;
            nullok[k] = segsum.cdescrs[k].nullok;
        }

        *n1 = *ncols;
        *n2 = *ncols;
        *n3 = *ncols;
        *n4 = *ncols;
        *n5 = *ncols;
        *n6 = *ncols;
        *n7 = *ncols;
    }


    void evsgp4_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "evsgp4" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            evsgp4_c(
                in11[i % in11_dim1],
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                out21_buffer + i * 6);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_getelm_c(
        SpiceInt    frstyr,
        SpiceInt    two, SpiceInt lineln, ConstSpiceChar *lines,
        SpiceDouble *epoch,
        SpiceDouble elems[10])
    {
        if (!my_assert_eq(two, 2, "getelm",
            "Array dimension error in getelm: "
            "lines rows = #; # is required")) return;

        getelm_c(frstyr, lineln, lines, epoch, elems);
    }


    void my_getfat_c(
        ConstSpiceChar *file,
        SpiceChar      arch[NAMELEN],
        SpiceChar      kertyp[NAMELEN])
    {
        getfat_c(file, NAMELEN-1, NAMELEN-1, arch, kertyp);
    }


    void my_getfvn_c(
        ConstSpiceChar *inst,
        SpiceChar      shape[NAMELEN],
        SpiceChar      frame[NAMELEN],
        SpiceDouble    bsight[3],
        SpiceDouble    bounds[FOVSHAPE][3], SpiceInt *n)
    {
        getfvn_c(inst, FOVSHAPE, NAMELEN-1, NAMELEN-1, shape, frame,
                 bsight, n, bounds);
    }


    void my_gfdist_c(
        ConstSpiceChar *target,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        ConstSpiceChar *relate,
        SpiceDouble    refval,
        SpiceDouble    adjust,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfdist_c(target, abcorr, obsrvr, relate, refval, adjust, step,
                 nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfevnt_c(
        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,
        SpiceDouble       windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        gfsstp_c(step);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfevnt_c(&gfstep_c, &gfrefn_c, gquant, qnpars,
                 NAMELEN, qpnams, qcpars, qdpars, qipars, qlpars, op,
                 refval, tol, adjust, rpt, &gfrepi_c, &gfrepu_c, &gfrepf_c,
                 nintvls, SPICEFALSE, NULL, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gffove_c(
        ConstSpiceChar   *inst,
        ConstSpiceChar   *tshape,
        ConstSpiceDouble raydir[3],
        ConstSpiceChar   *target,
        ConstSpiceChar   *tframe,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *obsrvr,
        SpiceDouble      tol,
        SpiceDouble      step,
        SpiceBoolean     rpt,
        SpiceDouble      et0,
        SpiceDouble      et1,
        SpiceDouble      windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        gfsstp_c(step);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        gffove_c(inst, tshape, raydir, target, tframe, abcorr, obsrvr,
                 tol, &gfstep_c, &gfrefn_c, rpt, &gfrepi_c, &gfrepu_c, &gfrepf_c,
                 SPICEFALSE, NULL, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfilum_c(
        ConstSpiceChar   *method,
        ConstSpiceChar   *angtyp,
        ConstSpiceChar   *target,
        ConstSpiceChar   *illmn,
        ConstSpiceChar   *fixref,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *obsrvr,
        ConstSpiceDouble spoint[3],
        ConstSpiceChar   *relate,
        SpiceDouble      refval,
        SpiceDouble      adjust,
        SpiceDouble      step,
        SpiceDouble      et0,
        SpiceDouble      et1,
        SpiceDouble      windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfilum_c(method, angtyp, target, illmn, fixref, abcorr, obsrvr,
                 spoint, relate, refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfocce_c(
        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,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        gfsstp_c(step);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        gfocce_c(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr, obsrvr,
                 tol, &gfstep_c, &gfrefn_c, rpt, &gfrepi_c, &gfrepu_c, &gfrepf_c,
                 SPICEFALSE, NULL, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfoclt_c(
        ConstSpiceChar *occtyp,
        ConstSpiceChar *front,
        ConstSpiceChar *fshape,
        ConstSpiceChar *fframe,
        ConstSpiceChar *back,
        ConstSpiceChar *bshape,
        ConstSpiceChar *bframe,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        gfoclt_c(occtyp, front, fshape, fframe, back, bshape, bframe, abcorr,
                 obsrvr, step, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfpa_c(
        ConstSpiceChar *target,
        ConstSpiceChar *illmn,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        ConstSpiceChar *relate,
        SpiceDouble    refval,
        SpiceDouble    adjust,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfpa_c(target, illmn, abcorr, obsrvr, relate,
               refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfposc_c(
        ConstSpiceChar *target,
        ConstSpiceChar *frame,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        ConstSpiceChar *crdsys,
        ConstSpiceChar *coord,
        ConstSpiceChar *relate,
        SpiceDouble    refval,
        SpiceDouble    adjust,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfposc_c(target, frame, abcorr, obsrvr, obsrvr, coord, relate,
                 refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfrfov_c(
        ConstSpiceChar   *inst,
        ConstSpiceDouble raydir[3],
        ConstSpiceChar   *rframe,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *obsrvr,
        SpiceDouble      step,
        SpiceDouble      et0,
        SpiceDouble      et1,
        SpiceDouble      windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        gfrfov_c(inst, raydir, rframe, abcorr, obsrvr,
                 step, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfrr_c(
        ConstSpiceChar *target,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        ConstSpiceChar *relate,
        SpiceDouble    refval,
        SpiceDouble    adjust,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfrr_c(target, abcorr, obsrvr, relate,
                 refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfsep_c(
        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,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfsep_c(targ1, shape1, frame1, targ2, shape2, frame2,
                abcorr, obsrvr, relate,
                refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfsntc_c(
        ConstSpiceChar   *target,
        ConstSpiceChar   *fixref,
        ConstSpiceChar   *method,
        ConstSpiceChar   *abcorr,
        ConstSpiceChar   *obsrvr,
        ConstSpiceChar   *dref,
        ConstSpiceDouble dvec[3],
        ConstSpiceChar   *crdsys,
        ConstSpiceChar   *coord,
        ConstSpiceChar   *relate,
        SpiceDouble      refval,
        SpiceDouble      adjust,
        SpiceDouble      step,
        SpiceDouble      et0,
        SpiceDouble      et1,
        SpiceDouble      windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfsntc_c(target, fixref, method, abcorr, obsrvr, dref, dvec,
                 crdsys, coord, relate,
                 refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gfsubc_c(
        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,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        int nintvls = 5 + (int) ((et1 - et0) / step);

        gfsubc_c(target, fixref, method, abcorr, obsrvr, crdsys,
                 coord, relate,
                 refval, adjust, step, nintvls, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_gftfov_c(
        ConstSpiceChar *inst,
        ConstSpiceChar *target,
        ConstSpiceChar *tshape,
        ConstSpiceChar *tframe,
        ConstSpiceChar *abcorr,
        ConstSpiceChar *obsrvr,
        SpiceDouble    step,
        SpiceDouble    et0,
        SpiceDouble    et1,
        SpiceDouble    windows[WINDOWS][2], int *intervals)
    {
        SPICEDOUBLE_CELL(cnfine, 2);
        wnvald_c(2, 0, &cnfine);
        wninsd_c(et0, et1, &cnfine);

        int j;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        scard_c(0, &cells);

        gftfov_c(inst, target, tshape, tframe, abcorr, obsrvr,
                 step, &cnfine, &cells);

        *intervals = (int) card_c(&cells) / 2;
        for (j = 0; j < *intervals; j++) {
            wnfetd_c(&cells, j, &(windows[j][0]), &(windows[j][1]));
        }
    }


    void my_hrmesp_c(
        SpiceDouble      first,
        SpiceDouble      step,
        ConstSpiceDouble *yvals, SpiceInt nx2,
        SpiceDouble      x,
        SpiceDouble      *f,
        SpiceDouble      *df)
    {
        hrmesp_c(nx2/2, first, step, yvals, x, f, df);
    }


    void hrmesp_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "hrmesp" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_hrmesp_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in13[i % in13_dim1],
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_hrmint_c(
        ConstSpiceDouble *xvals, SpiceInt n,
        ConstSpiceDouble *yvals, SpiceInt n2, SpiceInt two,
        SpiceDouble      x,
        SpiceDouble      *f,
        SpiceDouble      *df)
    {
        *f = 0.;
        *df = 0.;

        if (!my_assert_eq(n2, n, "hrmint",
            "Array dimension mismatch in hrmint: "
            "xvals dimension = #; yvals dimension = #")) return;

        if (!my_assert_eq(two, 2, "hrmint",
            "Array dimension error in hrmint: "
            "second yvals dimension = #; should be 2")) return;

        SpiceDouble *work = my_malloc(4 * n + 4, "hrmint");
        if (!work) return;

        hrmint_c(n, xvals, yvals, x, work, f, df);
        free(work);
    }


    void hrmint_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "hrmint" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in31_dim1) maxdim = in31_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_hrmint_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in31 + (i % in31_dim1) * in31_dim2 * in31_dim3, in31_dim2, in31_dim3,
                in11[i % in11_dim1],
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    void my_hx2dp_c(
        ConstSpiceChar *string,
        SpiceDouble    *number,
        SpiceBoolean   *error,
        SpiceInt       errmln, SpiceChar errmsg[MESSAGELEN])
    {
        hx2dp_c(string, errmln, number, error, errmsg);
    }


    void invstm_vector(
        ConstSpiceDouble *in31, int in31_dim1, int in31_dim2, int in31_dim3,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "invstm" "_vector";

        int maxdim = in31_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in31_dim1 = (in31_dim1 == 0 ? 1 : in31_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            invstm_c(
                in31 + (i) * in31_dim2 * in31_dim3,
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_kdata_c(
        SpiceInt       which,
        ConstSpiceChar *kind,
        SpiceInt       fileln, SpiceChar *file,
        SpiceInt       filtln, SpiceChar *filtyp,
        SpiceInt       srclen, SpiceChar *srcfil,
        SpiceInt       *handle,
        SpiceBoolean   *found)
    {
        kdata_c(which, kind, fileln, filtln, srclen,
                file, filtyp, srcfil, handle, found);
    }


    void my_kinfo_c(
        ConstSpiceChar *file,
        SpiceInt       filtln,  SpiceChar filtyp[NAMELEN],
        SpiceInt       srclen,  SpiceChar srcfil[FILELEN],
        SpiceInt       *handle,
        SpiceBoolean   *found)
    {
        kinfo_c(file, filtln, srclen, filtyp, srcfil, handle, found);
    }


    void my_kxtrct_c(
        ConstSpiceChar *keywd,
        SpiceInt       nterms, SpiceInt  termlen, ConstSpiceChar *terms,
        SpiceInt       worlen, SpiceChar *wordsq,
        SpiceBoolean   *found,
        SpiceInt       sublen, SpiceChar substr[MESSAGELEN])
    {
        kxtrct_c(keywd, termlen, terms, nterms, worlen, sublen, wordsq,
                 found, substr);
    }


    SpiceDouble my_lgresp_c(
        SpiceDouble      first,
        SpiceDouble      step,
        ConstSpiceDouble *yvals, SpiceInt n,
        SpiceDouble      x)
    {
        return lgresp_c(n, first, step, yvals, x);
    }


    void lgresp_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in13, int in13_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "lgresp" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in13_dim1) maxdim = in13_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in13_dim1 = (in13_dim1 == 0 ? 1 : in13_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_lgresp_c(
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in13[i % in13_dim1]);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_lgrind_c(
        ConstSpiceDouble *xvals, SpiceInt n,
        ConstSpiceDouble *yvals, SpiceInt n2,
        SpiceDouble x,
        SpiceDouble *p,
        SpiceDouble *dp)
    {
        *p = 0.;
        *dp = 0.;

        if (!my_assert_eq(n, n2, "lgrind",
            "Array dimension mismatch in lgrind: "
            "xvals dimension = #; yvals dimension = #")) return;

        SpiceDouble *work = my_malloc(2*n + 2, "lgrind");
        if (!work) return;

        lgrind_c(n, xvals, yvals, work, x, p, dp);
        free(work);
    }


    void lgrind_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1) {
        char *my_name = "lgrind" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        if (!out12_buffer) {
            free(out11_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            my_lgrind_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                in11[i % in11_dim1],
                out11_buffer + i,
                out12_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
    }


    SpiceDouble my_lgrint_c(
        ConstSpiceDouble *xvals, SpiceInt n,
        ConstSpiceDouble *yvals, SpiceInt n2,
        SpiceDouble x)
    {
        if (!my_assert_eq(n, n2, "lgrint",
            "Array dimension mismatch in lgrint: "
            "xvals dimension = #; yvals dimension = #")) return 0.;

        return lgrint_c(n, xvals, yvals, x);
    }


    void lgrint_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "lgrint" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = my_lgrint_c(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                in11[i % in11_dim1]);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_nextwd_c(
        ConstSpiceChar *string,
        SpiceInt       nexlen, SpiceChar next[COLLEN],
        SpiceInt       reslen, SpiceChar rest[MESSAGELEN])
    {
        nextwd_c(string, nexlen, reslen, next, rest);
    }


    void my_orderc_c(
        SpiceInt ndim, SpiceInt arrlen, ConstSpiceChar *array,
        SpiceInt *n,   SpiceInt **iorder)
    {
        SpiceInt *iorder1 = my_int_malloc(ndim, "orderc");
        if (!iorder1) return;

        orderc_c(arrlen, array, ndim, iorder1);

        *n = ndim;
        *iorder = iorder1;
    }


    void my_orderd_c(
        ConstSpiceDouble *array,
        SpiceInt         ndim,
        SpiceInt         *n, SpiceInt **iorder)
    {
        SpiceInt *iorder1 = my_int_malloc(ndim, "orderd");
        if (!iorder1) return;

        orderd_c(array, ndim, iorder1);

        *n = ndim;
        *iorder = iorder1;
    }


    void my_orderi_c(
        ConstSpiceInt *array, SpiceInt ndim,
        SpiceInt      *n,     SpiceInt **iorder)
    {
        SpiceInt *iorder1 = my_int_malloc(ndim, "orderi");
        if (!iorder1) return;

        orderi_c(array, ndim, iorder1);

        *n = ndim;
        *iorder = iorder1;
    }


    void pltnrm_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        ConstSpiceDouble *in23, int in23_dim1, int in23_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "pltnrm" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;
        if (maxdim < in23_dim1) maxdim = in23_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);
        in23_dim1 = (in23_dim1 == 0 ? 1 : in23_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            pltnrm_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2,
                in23 + (i % in23_dim1) * in23_dim2,
                out21_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_polyds_c(
        SpiceInt deg_plus_1, ConstSpiceDouble *coeffs,
        SpiceInt nderiv,
        SpiceDouble t,
        SpiceInt *nderiv_plus_1, SpiceDouble p[10])
    {
        polyds_c(coeffs, deg_plus_1 - 1, nderiv, t, p);
        *nderiv_plus_1 = nderiv + 1;
    }

    // This function doesn't fit any of our vectorization templates, because
    // the rightmost dimension of the returned axis is variable.

    void polyds_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceInt nderiv,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2)
    {
        char *my_name = "polyds_vector";

        // in21 is coeffs
        // in12 is t
        // out21 is p

        int deg = in21_dim1 - 1;
        int nderiv_plus_1 = nderiv + 1;

        *out21 = NULL;
        *out21_dim1 = 0;
        *out21_dim2 = nderiv_plus_1;

        int maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        SpiceDouble *out21_buffer = my_malloc(size * nderiv_plus_1, my_name);
        if (!out21_buffer) return;

        for (int i = 0; i < size; i++) {
            polyds_c(
                in21 + (i % in21_dim1) * in21_dim2,
                deg, nderiv,
                in12[i % in12_dim1],
                out21_buffer + i * nderiv_plus_1
            );
        }

        if (failed_c()) {
            free(out21_buffer);
            return;
        }

        *out21 = out21_buffer;
        *out21_dim1 = maxdim;
        *out21_dim2 = nderiv_plus_1;
    }


    void my_qderiv_c(
        SpiceInt    ndim, ConstSpiceDouble *f0,
        SpiceInt    ndim1, ConstSpiceDouble *f2,
        SpiceDouble delta,
        SpiceInt    *ndim2, SpiceDouble **dfdt)
    {
        *dfdt = NULL;
        *ndim2 = 0;

        if (!my_assert_eq(ndim, ndim1, "qderiv",
            "Array dimension mismatch in qderiv: "
            "f0 dimension = #; f2 dimension = #")) return;

        SpiceDouble *result = my_malloc(ndim, "qderiv");
        if (!result) return;

        qderiv_c(ndim, f0, f2, delta, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *dfdt = result;
        *ndim2 = ndim;
    }


    void recazl_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceDouble *in12, int in12_dim1,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out13, int *out13_dim1) {
        char *my_name = "recazl" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out13 = NULL; *out13_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out13_buffer = out12_buffer ? my_malloc(size, my_name) : NULL;
        if (!out13_buffer) {
            free(out11_buffer);
            free(out12_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            recazl_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                in12[i % in12_dim1],
                out11_buffer + i,
                out12_buffer + i,
                out13_buffer + i);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
    }


    void spkcpo_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkcpo" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkcpo_c(
                str1,
                in11[i % in11_dim1],
                str2,
                str3,
                str4,
                in21 + (i % in21_dim1) * in21_dim2,
                str5,
                str6,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkcpt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkcpt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkcpt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                str4,
                str5,
                str6,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkcvo_vector(
        ConstSpiceChar *str1,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkcvo" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkcvo_c(
                str1,
                in11[i % in11_dim1],
                str2,
                str3,
                str4,
                in21 + (i % in21_dim1) * in21_dim2,
                in12[i % in12_dim1],
                str5,
                str6,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void spkcvt_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in12, int in12_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "spkcvt" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in11_dim1) maxdim = in11_dim1;
        if (maxdim < in12_dim1) maxdim = in12_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in12_dim1 = (in12_dim1 == 0 ? 1 : in12_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 6;
        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out21_buffer = my_malloc(size * 6, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        if (!out11_buffer) {
            free(out21_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            spkcvt_c(
                in21 + (i % in21_dim1) * in21_dim2,
                in11[i % in11_dim1],
                str1,
                str2,
                in12[i % in12_dim1],
                str3,
                str4,
                str5,
                str6,
                out21_buffer + i * 6,
                out11_buffer + i);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void my_spksfs_c(
        SpiceInt     body,
        SpiceDouble  et,
        SpiceInt     *handle,
        SpiceDouble  descr[5],
        SpiceInt     idlen, SpiceChar *ident,
        SpiceBoolean *found)
    {
        spksfs_c(body, et, idlen, handle, descr, ident, found);
    }


    void my_spkw18_c(
        SpiceInt          handle,
        ConstSpiceChar    *subtyp,
        SpiceInt          body,
        SpiceInt          center,
        ConstSpiceChar    *frame,
        SpiceDouble       first,
        SpiceDouble       last,
        ConstSpiceChar    *segid,
        SpiceInt          degree,
        SpiceInt          n,
        ConstSpiceDouble  *packts,
        ConstSpiceDouble  *epochs)
    {
        SpiceSPK18Subtype subtyp_;
        if (strcmp(subtyp, "S18TP0") == 0) {
            subtyp_ = S18TP0;
        } else if (strcmp(subtyp, "S18TP1") == 0) {
            subtyp_ = S18TP1;
        } else {
            chkin_c("spkw18");
            setmsg_c("subtyp value must be one of {\"S18TP0\", \"S18TP0\"}");
            sigerr_c("SPICE(SPICE(INVALIDARGUMENT)");
            chkout_c("spkw18");
            return;
        }

        spkw18_c(handle, subtyp_, body, center, frame, first, last, segid,
                 degree, n, packts, epochs);
    }


    void tangpt_vector(
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceChar *str7,
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2,
        SpiceDouble **out11, int *out11_dim1,
        SpiceDouble **out12, int *out12_dim1,
        SpiceDouble **out22, int *out22_dim1, int *out22_dim2,
        SpiceDouble **out13, int *out13_dim1,
        SpiceDouble **out23, int *out23_dim1, int *out23_dim2) {
        char *my_name = "tangpt" "_vector";

        int maxdim = in11_dim1;
        if (maxdim < in21_dim1) maxdim = in21_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = 3;
        *out11 = NULL; *out11_dim1 = 0;
        *out12 = NULL; *out12_dim1 = 0;
        *out22 = NULL; *out22_dim1 = 0; *out22_dim2 = 3;
        *out13 = NULL; *out13_dim1 = 0;
        *out23 = NULL; *out23_dim1 = 0; *out23_dim2 = 3;

        SpiceDouble *out21_buffer = my_malloc(size * 3, my_name);
        SpiceDouble *out11_buffer = out21_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out12_buffer = out11_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out22_buffer = out12_buffer ? my_malloc(size * 3, my_name) : NULL;
        SpiceDouble *out13_buffer = out22_buffer ? my_malloc(size, my_name) : NULL;
        SpiceDouble *out23_buffer = out13_buffer ? my_malloc(size * 3, my_name) : NULL;
        if (!out23_buffer) {
            free(out21_buffer);
            free(out11_buffer);
            free(out12_buffer);
            free(out22_buffer);
            free(out13_buffer);
            return;
        }

        for (int i = 0; i < size; i++) {
            tangpt_c(
                str1,
                str2,
                in11[i % in11_dim1],
                str3,
                str4,
                str5,
                str6,
                str7,
                in21 + (i % in21_dim1) * in21_dim2,
                out21_buffer + i * 3,
                out11_buffer + i,
                out12_buffer + i,
                out22_buffer + i * 3,
                out13_buffer + i,
                out23_buffer + i * 3);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
        *out11 = out11_buffer; *out11_dim1 = maxdim;
        *out12 = out12_buffer; *out12_dim1 = maxdim;
        *out22 = out22_buffer; *out22_dim1 = maxdim;
        *out13 = out13_buffer; *out13_dim1 = maxdim;
        *out23 = out23_buffer; *out23_dim1 = maxdim;
    }


    void trgsep_vector(
        ConstSpiceDouble *in11, int in11_dim1,
        ConstSpiceChar *str1,
        ConstSpiceChar *str2,
        ConstSpiceChar *str3,
        ConstSpiceChar *str4,
        ConstSpiceChar *str5,
        ConstSpiceChar *str6,
        ConstSpiceChar *str7,
        ConstSpiceChar *str8,
        SpiceDouble **out11, int *out11_dim1) {
        char *my_name = "trgsep" "_vector";

        int maxdim = in11_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in11_dim1 = (in11_dim1 == 0 ? 1 : in11_dim1);

        *out11 = NULL; *out11_dim1 = 0;

        SpiceDouble *out11_buffer = my_malloc(size, my_name);
        if (!out11_buffer) return;
        for (int i = 0; i < size; i++) {
            out11_buffer[i] = trgsep_c(
                in11[i],
                str1,
                str2,
                str3,
                str4,
                str5,
                str6,
                str7,
                str8);
        }

        *out11 = out11_buffer; *out11_dim1 = maxdim;
    }


    void twovxf_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        SpiceInt k1,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceInt k2,
        SpiceDouble **out31, int *out31_dim1, int *out31_dim2, int *out31_dim3) {
        char *my_name = "twovxf" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out31 = NULL; *out31_dim1 = 0; *out31_dim2 = 6; *out31_dim3 = 6;

        SpiceDouble *out31_buffer = my_malloc(size * 6 * 6, my_name);
        if (!out31_buffer) return;
        for (int i = 0; i < size; i++) {
            twovxf_c(
                in21 + (i % in21_dim1) * in21_dim2,
                k1,
                in22 + (i % in22_dim1) * in22_dim2,
                k2,
                out31_buffer + i * 6 * 6);
        }

        *out31 = out31_buffer; *out31_dim1 = maxdim;
    }


    void my_vprojg_c(
        ConstSpiceDouble *a, SpiceInt ndim,
        ConstSpiceDouble *b, SpiceInt ndim1, 
        SpiceDouble     **p, SpiceInt *ndim2)
    {
        *p = NULL;
        *ndim2 = 0;

        if (!my_assert_eq(ndim, ndim1, "vprojg",
            "Array dimension mismatch in vprojg: "
            "a elements = #; b elements = #")) return;

        SpiceDouble *result = my_malloc(ndim, "vprojg");
        if (!result) return;

        vprojg_c(a, b, ndim, result);

        if (failed_c()) {
            free(result);
            return;
        }

        *p = result;
        *ndim2 = ndim;
    }

    void my_vprojg_nomalloc(
        ConstSpiceDouble *a, SpiceInt ndim,
        ConstSpiceDouble *b, SpiceInt ndim1, 
        SpiceDouble      *p, SpiceInt *ndim2)
    {
        if (!my_assert_eq(ndim, ndim1, "vprojg",
            "Array dimension mismatch in vprojg: "
            "a elements = #; b elements = #")) return;

        vprojg_c(a, b, ndim, p);
        *ndim2 = ndim;
    }


    void vprojg_vector(
        ConstSpiceDouble *in21, int in21_dim1, int in21_dim2,
        ConstSpiceDouble *in22, int in22_dim1, int in22_dim2,
        SpiceDouble **out21, int *out21_dim1, int *out21_dim2) {
        char *my_name = "vprojg" "_vector";

        int maxdim = in21_dim1;
        if (maxdim < in22_dim1) maxdim = in22_dim1;

        int size = (maxdim == 0 ? 1 : maxdim);
        in21_dim1 = (in21_dim1 == 0 ? 1 : in21_dim1);
        in22_dim1 = (in22_dim1 == 0 ? 1 : in22_dim1);

        *out21 = NULL; *out21_dim1 = 0; *out21_dim2 = in22_dim2;

        SpiceDouble *out21_buffer = my_malloc(size * in22_dim2, my_name);
        if (!out21_buffer) return;
        for (int i = 0; i < size; i++) {
            my_vprojg_nomalloc(
                in21 + (i % in21_dim1) * in21_dim2, in21_dim2,
                in22 + (i % in22_dim1) * in22_dim2, in22_dim2,
                out21_buffer + i * in22_dim2, out21_dim2);
        }

        *out21 = out21_buffer; *out21_dim1 = maxdim;
    }


    void my_wncomd_c(
        SpiceDouble left,
        SpiceDouble right,
        int         n,   SpiceDouble window[][2],
        int         *n1, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells1, 2 * WINDOWS);
        moved_c(window, nx2, cells1.data);
        wnvald_c(2 * WINDOWS, nx2, &cells1);

        SPICEDOUBLE_CELL(cells2, 2 * WINDOWS);
        scard_c(0, &cells2);

        wncomd_c(left, right, &cells1, &cells2);

        nx2 = (int) card_c(&cells2);
        moved_c(cells2.data, nx2, result);
        *n1 = nx2 / 2;
    }


    void my_wncond_c(
        SpiceDouble left,
        SpiceDouble right,
        int n, SpiceDouble window[][2],
        int *size, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wncond_c(left, right, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *size = nx2 / 2;
    }


    void my_wndifd_c(
        int na,  ConstSpiceDouble a[][2],
        int nb,  ConstSpiceDouble b[][2],
        int *nc, SpiceDouble c[WINDOWS][2])
    {
        int nx2 = 2 * na;
        SPICEDOUBLE_CELL(cells_a, 2 * WINDOWS);
        moved_c(a, nx2, cells_a.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_a);

        nx2 = 2 * nb;
        SPICEDOUBLE_CELL(cells_b, 2 * WINDOWS);
        moved_c(b, nx2, cells_b.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_b);

        nx2 = 2 * WINDOWS;
        SPICEDOUBLE_CELL(cells_c, 2 * WINDOWS);
        scard_c(0, &cells_c);

        wndifd_c(&cells_a, &cells_b, &cells_c);

        nx2 = (int) card_c(&cells_c);
        moved_c(cells_c.data, nx2, c);
        *nc = nx2 / 2;
    }


    SpiceBoolean my_wnelmd_c(
        SpiceDouble point,
        int n, SpiceDouble window[][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        return wnelmd_c(point, &cells);
    }


    void my_wnexpd_c(
        SpiceDouble left,
        SpiceDouble right,
        int n, SpiceDouble window[][2],
        int *size, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wnexpd_c(left, right, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *size = nx2 / 2;
    }


    void my_wnextd_c(
        SpiceChar side,
        int n, SpiceDouble window[][2],
        int *size, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);

        wnextd_c(side, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *size = nx2 / 2;
    }


    void my_wnfild_c(
        SpiceDouble smlgap,
        int n, SpiceDouble window[][2],
        int *n1, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wnfild_c(smlgap, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *n1 = nx2 / 2;
    }


    void my_wnfltd_c(
        SpiceDouble smlint,
        int n,   ConstSpiceDouble window[][2],
        int *n1, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wnfltd_c(smlint, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *n1 = nx2 / 2;
    }


    SpiceBoolean my_wnincd_c(
        SpiceDouble left,
        SpiceDouble right,
        int n, ConstSpiceDouble window[][2])
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        return wnincd_c(left, right, &cells);
    }


    void my_wninsd_c(
        SpiceDouble left,
        SpiceDouble right,
        int n, ConstSpiceDouble window[][2],
        int *n1, SpiceDouble result[WINDOWS][2])
    {
        int nx2 = n * 2;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wninsd_c(left, right, &cells);

        nx2 = (int) card_c(&cells);
        moved_c(cells.data, nx2, result);
        *n1 = nx2 / 2;
    }


    void my_wnintd_c(
        int na,  ConstSpiceDouble a[][2],
        int nb,  ConstSpiceDouble b[][2],
        int *nc, SpiceDouble c[WINDOWS][2])
    {
        int nx2 = 2 * na;
        SPICEDOUBLE_CELL(cells_a, 2 * WINDOWS);
        moved_c(a, nx2, cells_a.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_a);

        nx2 = 2 * nb;
        SPICEDOUBLE_CELL(cells_b, 2 * WINDOWS);
        moved_c(b, nx2, cells_b.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_b);

        nx2 = 2 * WINDOWS;
        SPICEDOUBLE_CELL(cells_c, 2 * WINDOWS);
        scard_c(0, &cells_c);

        wnintd_c(&cells_a, &cells_b, &cells_c);

        nx2 = (int) card_c(&cells_c);
        moved_c(cells_c.data, nx2, c);
        *nc = nx2 / 2;
    }


    SpiceBoolean my_wnreld_c(
        int na, ConstSpiceDouble a[][2],
        ConstSpiceChar *op,
        int nb, ConstSpiceDouble b[][2])
    {
        int nx2 = 2 * na;
        SPICEDOUBLE_CELL(cells_a, 2 * WINDOWS);
        moved_c(a, nx2, cells_a.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_a);

        nx2 = 2 * nb;
        SPICEDOUBLE_CELL(cells_b, 2 * WINDOWS);
        moved_c(b, nx2, cells_b.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_b);

        return wnreld_c(&cells_a, op, &cells_b);
    }


    void my_wnsumd_c(
        int n, ConstSpiceDouble window[][2],
        SpiceDouble *meas,
        SpiceDouble *avg,
        SpiceDouble *stddev,
        SpiceInt    *idxsml,
        SpiceInt    *idxlon)
    {
        int nx2 = 2 * n;
        SPICEDOUBLE_CELL(cells, 2 * WINDOWS);
        moved_c(window, nx2, cells.data);
        wnvald_c(2 * WINDOWS, nx2, &cells);

        wnsumd_c(&cells, meas, avg, stddev, idxsml, idxlon);
    }


    void my_wnunid_c(
        int na,  ConstSpiceDouble a[][2],
        int nb,  ConstSpiceDouble b[][2],
        int *nc, SpiceDouble c[WINDOWS][2])
    {
        int nx2 = 2 * na;
        SPICEDOUBLE_CELL(cells_a, 2 * WINDOWS);
        moved_c(a, nx2, cells_a.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_a);

        nx2 = 2 * nb;
        SPICEDOUBLE_CELL(cells_b, 2 * WINDOWS);
        moved_c(b, nx2, cells_b.data);
        wnvald_c(2 * WINDOWS, nx2, &cells_b);

        nx2 = 2 * WINDOWS;
        SPICEDOUBLE_CELL(cells_c, 2 * WINDOWS);
        scard_c(0, &cells_c);

        wnunid_c(&cells_a, &cells_b, &cells_c);

        nx2 = (int) card_c(&cells_c);
        moved_c(cells_c.data, nx2, c);
        *nc = nx2 / 2;
    }

#ifdef __cplusplus
extern "C" {
#endif
SWIGINTERN PyObject *_wrap_axisar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble (*arg3)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("axisar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "axisar", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("axisar", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("axisar", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "axisar" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  axisar_c(arg1,arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("axisar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_axisar_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
    arg9 = &dimsize6[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "axisar_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("axisar_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("axisar_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  axisar_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("axisar_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("axisar_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize6[0], dimsize6[1], dimsize6[2]
    };
    if (dims[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("axisar_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_b1900(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "b1900", 0, 0, 0)) SWIG_fail;
  result = b1900_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("b1900");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_b1950(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "b1950", 0, 0, 0)) SWIG_fail;
  result = b1950_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("b1950");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bltfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("bltfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bltfrm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_bltfrm_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bltfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodc2n(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("bodc2n");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bodc2n" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  bodc2n_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodc2n");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodc2s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("bodc2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bodc2s" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  bodc2s_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodc2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_boddef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "boddef", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("boddef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("boddef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "boddef" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  boddef_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("boddef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodfnd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "bodfnd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bodfnd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("bodfnd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodfnd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = bodfnd_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodfnd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodn2c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceBoolean mybool3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("bodn2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodn2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  bodn2c_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodn2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bods2c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceBoolean mybool3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("bods2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bods2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  bods2c_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bods2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodvar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      80
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("bodvar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg3 = &size3[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "bodvar", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bodvar" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("bodvar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodvar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  bodvar_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodvar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodvcd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      KERVALS
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("bodvcd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg4 = &size3[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "bodvcd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bodvcd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("bodvcd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodvcd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  bodvcd_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodvcd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bodvrd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      KERVALS
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg4 = &size3[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "bodvrd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  bodvrd_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bodvrd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ccifrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, NAMELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("ccifrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  arg6 = &temp6;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "ccifrm", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ccifrm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ccifrm" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  my_ccifrm_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ccifrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cgv2el(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NELLIPSE
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("cgv2el");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "cgv2el", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("cgv2el", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("cgv2el", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("cgv2el", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("cgv2el", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("cgv2el", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("cgv2el", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  cgv2el_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cgv2el");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cgv2el_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "cgv2el_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("cgv2el_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("cgv2el_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("cgv2el_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  cgv2el_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cgv2el_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("cgv2el_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("cgv2el_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chkin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("chkin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("chkin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  chkin_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chkin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_chkout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("chkout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("chkout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  chkout_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chkout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cidfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("cidfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cidfrm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_cidfrm_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cidfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckcov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceBoolean arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble (*arg7)[2] ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize7[0] = (int) dims[0];
    dimsize7[1] = (int) dims[1];
    
    arg7 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr7);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr7, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr7, 1);                           // DIM2
    arg8 = &dimsize7[0];                                           // SIZE1
    //  $5 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "ckcov", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckcov" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckcov" "', argument " "3"" of type '" "SpiceBoolean""'");
  } 
  arg3 = (SpiceBoolean)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ckcov" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_ckcov_c(arg1,arg2,arg3,arg4,arg5,arg6,(SpiceDouble (*)[2])arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr7, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble (*arg5)[3] ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("ckgp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  arg6 = &temp6;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgp", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgp" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckgp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckgp" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ckgp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckgp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ckgp_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[3])arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceBoolean **arg13 = (SpiceBoolean **) 0 ;
  int *arg14 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceBoolean *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgp_vector", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgp_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckgp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ckgp_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ckgp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckgp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("ckgp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceBoolean));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckgp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgpav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble (*arg5)[3] ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceBoolean *arg8 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceBoolean mybool8 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("ckgpav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("ckgpav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg8 = &mybool8;
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgpav", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgpav" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckgpav" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckgpav" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ckgpav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckgpav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ckgpav_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[3])arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgpav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg8 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgpav_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceBoolean **arg16 = (SpiceBoolean **) 0 ;
  int *arg17 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[1] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceBoolean *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgpav_vector", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgpav_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckgpav_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ckgpav_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ckgpav_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize14[0], 1);
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14, dim * sizeof(SpiceDouble));
    if (dimsize14[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr14, PyArray_DATA(pyarr14));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckgpav_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr14 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr14);
      // AppendOutput steals the reference to the argument.
      pyarr14 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("ckgpav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceBoolean));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckgpav_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckobj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 ;
  int *arg3 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("ckobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ckobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_ckobj_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_clight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "clight", 0, 0, 0)) SWIG_fail;
  result = clight_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("clight");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_clpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "clpool", 0, 0, 0)) SWIG_fail;
  clpool_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("clpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cnmfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("cnmfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("cnmfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cnmfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_cnmfrm_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cnmfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conics(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("conics");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "conics", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("conics", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (8))) {
        handle_invalid_array_shape_1d("conics", pyarr1, 8);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "conics" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  conics_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("conics");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_conics_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "conics_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("conics_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("conics_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  conics_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("conics_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("conics_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("conics_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_convrt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "convrt", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "convrt" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("convrt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("convrt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("convrt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("convrt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  convrt_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("convrt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_convrt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "convrt_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("convrt_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  convrt_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize5[0], 1);
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("convrt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dim * sizeof(SpiceDouble));
    if (dimsize5[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr5, PyArray_DATA(pyarr5));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("convrt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr5 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
      // AppendOutput steals the reference to the argument.
      pyarr5 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cyllat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "cyllat", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cyllat" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cyllat" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cyllat" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  cyllat_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cyllat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cyllat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "cyllat_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("cyllat_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("cyllat_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("cyllat_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  cyllat_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cyllat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cyllat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("cyllat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cyllat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cylrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("cylrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "cylrec", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cylrec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cylrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cylrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  cylrec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cylrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cylrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "cylrec_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("cylrec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("cylrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("cylrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  cylrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cylrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("cylrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("cylrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cylsph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "cylsph", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cylsph" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cylsph" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cylsph" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  cylsph_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cylsph");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cylsph_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "cylsph_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("cylsph_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("cylsph_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("cylsph_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  cylsph_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cylsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cylsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("cylsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("cylsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafbfs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafbfs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafbfs_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafbfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafcls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafgda(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dafgda");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dafgda", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafgda" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dafgda" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dafgda" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  dafgda_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafgda");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceChar *arg2 ;
  SpiceChar *buffer1 = NULL ;
  size_t dim11 ;
  int alloc1 = 0 ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim11 = max(1, NAMELEN);
    buffer1 = (SpiceChar *) PyMem_Malloc((dim11 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer1)) {
        handle_malloc_failure("dafgn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc1 = SWIG_NEWOBJ;
    
    buffer1[0] = '\0';   // String begins empty
    arg2 = buffer1;                                                // STRING
    arg1 = (SpiceInt)dim11;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "dafgn", 0, 0, 0)) SWIG_fail;
  dafgn_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafgn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer1[dim11-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer1);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc1)) {
      PyMem_Free((void *) buffer1);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc1)) {
      PyMem_Free((void *) buffer1);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafgs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 ;
  PyArrayObject *pyarr1 = NULL ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // DIMENSIONS
    pyarr1 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr1)) {
        handle_malloc_failure("dafgs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dafgs", 0, 0, 0)) SWIG_fail;
  dafgs_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafgs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr1);
    // AppendOutput steals the reference to the argument.
    pyarr1 = NULL;
  }
  {
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_daffna(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean *arg1 = (SpiceBoolean *) 0 ;
  SpiceBoolean mybool1 ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg1 = &mybool1;
  }
  if (!SWIG_Python_UnpackTuple(args, "daffna", 0, 0, 0)) SWIG_fail;
  daffna_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("daffna");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg1 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafopr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dafopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dafopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dafopr_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  SpiceInt *arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dafus");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("dafus");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceInt *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dafus", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dafus", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (DAFSIZE))) {
        handle_invalid_array_shape_1d("dafus", pyarr1, DAFSIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dafus" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dafus" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  dafus_c(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dcyldr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dcyldr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dcyldr", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dcyldr" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dcyldr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dcyldr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  dcyldr_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dcyldr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dcyldr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dcyldr_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dcyldr_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dcyldr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("dcyldr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  dcyldr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dcyldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dcyldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dcyldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_deltet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "deltet", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "deltet" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("deltet");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("deltet");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  deltet_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("deltet");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_deltet_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "deltet_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("deltet_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("deltet_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("deltet_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  deltet_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("deltet_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("deltet_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("deltet_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("deltet_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_det(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("det", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("det", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  result = det_c((ConstSpiceDouble (*)[3])arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("det");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_det_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("det_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  det_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("det_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("det_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize5[0], 1);
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("det_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dim * sizeof(SpiceDouble));
    if (dimsize5[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr5, PyArray_DATA(pyarr5));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("det_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr5 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
      // AppendOutput steals the reference to the argument.
      pyarr5 = NULL;
    }
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgeodr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble (*arg6)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("dgeodr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr6);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr6, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dgeodr", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dgeodr" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dgeodr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dgeodr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dgeodr" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dgeodr" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  dgeodr_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dgeodr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dgeodr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[3] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
    arg14 = &dimsize11[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dgeodr_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dgeodr_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dgeodr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("dgeodr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("dgeodr_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("dgeodr_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  dgeodr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dgeodr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("dgeodr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize11[0], dimsize11[1], dimsize11[2]
    };
    if (dims[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("dgeodr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
    pyarr11 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diags2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[2] ;
  SpiceDouble (*arg2)[2] ;
  SpiceDouble (*arg3)[2] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      2, 2
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("diags2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      2, 2
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("diags2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("diags2", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (2) || PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_2d("diags2", pyarr1, 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  diags2_c((ConstSpiceDouble (*)[2])arg1,(SpiceDouble (*)[2])arg2,(SpiceDouble (*)[2])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("diags2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_diags2_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("diags2_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  diags2_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("diags2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("diags2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("diags2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("diags2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("diags2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlatdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dlatdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dlatdr", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlatdr" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dlatdr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dlatdr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  dlatdr_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlatdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlatdr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dlatdr_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dlatdr_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dlatdr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("dlatdr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  dlatdr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlatdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dlatdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dlatdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpgrdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble (*arg7)[3] ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dpgrdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg7 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr7);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr7, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dpgrdr", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dpgrdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dpgrdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dpgrdr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dpgrdr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dpgrdr" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dpgrdr" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dpgrdr" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  dpgrdr_c(arg1,arg2,arg3,arg4,arg5,arg6,(SpiceDouble (*)[3])arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dpgrdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpgrdr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[3] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
    arg15 = &dimsize12[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dpgrdr_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dpgrdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dpgrdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dpgrdr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dpgrdr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("dpgrdr_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("dpgrdr_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("dpgrdr_vector", NPY_DOUBLE, swig_obj[5], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    if (PyArray_NDIM(pyarr10) == 0) {
      arg11 = 0;                                                 // DIM1
    } else {
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
    }
  }
  dpgrdr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dpgrdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("dpgrdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize12[0], dimsize12[1], dimsize12[2]
    };
    if (dims[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("dpgrdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "dpmax", 0, 0, 0)) SWIG_fail;
  result = dpmax_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dpmax");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "dpmin", 0, 0, 0)) SWIG_fail;
  result = dpmin_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dpmin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dpr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "dpr", 0, 0, 0)) SWIG_fail;
  result = dpr_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dpr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdcyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("drdcyl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdcyl", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drdcyl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdcyl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdcyl" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  drdcyl_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdcyl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdcyl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdcyl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("drdcyl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("drdcyl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("drdcyl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  drdcyl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("drdcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("drdcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdgeo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble (*arg6)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("drdgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr6);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr6, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdgeo", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drdgeo" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdgeo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdgeo" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drdgeo" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drdgeo" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  drdgeo_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdgeo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[3] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
    arg14 = &dimsize11[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdgeo_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("drdgeo_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("drdgeo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("drdgeo_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("drdgeo_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("drdgeo_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  drdgeo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("drdgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize11[0], dimsize11[1], dimsize11[2]
    };
    if (dims[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("drdgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
    pyarr11 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdlat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("drdlat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdlat", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drdlat" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdlat" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdlat" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  drdlat_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdlat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdlat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdlat_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("drdlat_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("drdlat_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("drdlat_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  drdlat_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("drdlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("drdlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdpgr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble (*arg7)[3] ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("drdpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg7 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr7);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr7, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdpgr", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("drdpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("drdpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdpgr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdpgr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drdpgr" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drdpgr" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "drdpgr" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  drdpgr_c(arg1,arg2,arg3,arg4,arg5,arg6,(SpiceDouble (*)[3])arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdpgr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[3] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
    arg15 = &dimsize12[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdpgr_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("drdpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("drdpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("drdpgr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("drdpgr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("drdpgr_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("drdpgr_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("drdpgr_vector", NPY_DOUBLE, swig_obj[5], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    if (PyArray_NDIM(pyarr10) == 0) {
      arg11 = 0;                                                 // DIM1
    } else {
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
    }
  }
  drdpgr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("drdpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize12[0], dimsize12[1], dimsize12[2]
    };
    if (dims[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("drdpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdsph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("drdsph");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdsph", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drdsph" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdsph" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdsph" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  drdsph_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdsph");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdsph_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdsph_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("drdsph_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("drdsph_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("drdsph_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  drdsph_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("drdsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("drdsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dsphdr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dsphdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dsphdr", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dsphdr" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dsphdr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dsphdr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  dsphdr_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dsphdr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dsphdr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dsphdr_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dsphdr_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dsphdr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("dsphdr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  dsphdr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dsphdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dsphdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dsphdr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dtpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceBoolean *arg2 = (SpiceBoolean *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceChar *arg4 ;
  int alloc1 = 0 ;
  SpiceBoolean mybool2 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg2 = &mybool2;
  }
  arg3 = &temp3;
  {
    //      (char OUT_STRING[ANY])
    
    dim14 = max(1, 2);
    buffer4 = (char *) PyMem_Malloc((dim14 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("dtpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg4 = buffer4;                                                // STRING
    //  $2 = dim14;                                                  // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dtpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dtpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dtpool_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dtpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg2 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ducrss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("ducrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ducrss", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ducrss", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("ducrss", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ducrss", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("ducrss", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ducrss_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ducrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ducrss_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "ducrss_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ducrss_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ducrss_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  ducrss_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ducrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("ducrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("ducrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvcrss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("dvcrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dvcrss", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvcrss", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dvcrss", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dvcrss", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("dvcrss", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dvcrss_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvcrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvcrss_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dvcrss_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvcrss_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dvcrss_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  dvcrss_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dvcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dvcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvdot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "dvdot", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvdot", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dvdot", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dvdot", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("dvdot", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = dvdot_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvdot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvdot_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dvdot_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvdot_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dvdot_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  dvdot_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dvdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dvdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dvdot_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvhat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("dvhat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvhat", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dvhat", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  dvhat_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvhat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvhat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvhat_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  dvhat_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("dvhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dvhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvnorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvnorm", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dvnorm", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = dvnorm_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvnorm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvnorm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvnorm_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  dvnorm_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("dvnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dvnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dvnorm_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dvpool_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvsep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "dvsep", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvsep", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dvsep", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dvsep", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("dvsep", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = dvsep_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dvsep_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dvsep_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dvsep_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dvsep_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  dvsep_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dvsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("dvsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dvsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dvsep_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_edlimb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NELLIPSE
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("edlimb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "edlimb", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "edlimb" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "edlimb" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "edlimb" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("edlimb", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("edlimb", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  edlimb_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("edlimb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_edlimb_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "edlimb_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("edlimb_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("edlimb_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("edlimb_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("edlimb_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  edlimb_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("edlimb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("edlimb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("edlimb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_edterm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  SpiceDouble *arg9 = (SpiceDouble *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  SpiceDouble temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyObject *swig_obj[8] ;
  
  arg9 = &temp9;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "edterm", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "edterm" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "edterm" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  my_edterm_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("edterm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_el2cgv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("el2cgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("el2cgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("el2cgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("el2cgv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NELLIPSE))) {
        handle_invalid_array_shape_1d("el2cgv", pyarr1, NELLIPSE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  el2cgv_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("el2cgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_el2cgv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("el2cgv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  el2cgv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("el2cgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eqncpv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("eqncpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "eqncpv", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "eqncpv" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eqncpv" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("eqncpv", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (9))) {
        handle_invalid_array_shape_1d("eqncpv", pyarr3, 9);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "eqncpv" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "eqncpv" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  eqncpv_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eqncpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eqncpv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "eqncpv_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("eqncpv_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("eqncpv_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("eqncpv_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("eqncpv_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("eqncpv_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    if (PyArray_NDIM(pyarr10) == 0) {
      arg11 = 0;                                                 // DIM1
    } else {
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
    }
  }
  eqncpv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eqncpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("eqncpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("eqncpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_erract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "erract", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("erract");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("erract");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, char INOUT_STRING[ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("erract");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&buffer2, &dim12, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("erract");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    resize_char_array_to_minimum_size(&buffer2, &dim12, NAMELEN, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("erract");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  my_erract_c(arg1,arg2,arg3);
  resultobj = SWIG_Py_Void();
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_errch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "errch", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("errch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("errch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  errch_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("errch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_errdev(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "errdev", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, char INOUT_STRING[ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&buffer2, &dim12, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    resize_char_array_to_minimum_size(&buffer2, &dim12, FILELEN, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  errdev_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("errdev");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_errdp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "errdp", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("errdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errdp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  errdp_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("errdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_errint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "errint", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("errint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errint" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  errint_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("errint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_errprt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "errprt", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, char INOUT_STRING[ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&buffer2, &dim12, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    resize_char_array_to_minimum_size(&buffer2, &dim12, MESSAGELEN, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  errprt_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("errprt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_et2lst(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  SpiceInt arg8 ;
  SpiceChar *arg9 ;
  SpiceInt arg10 ;
  SpiceChar *arg11 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceChar *buffer8 = NULL ;
  size_t dim18 ;
  int alloc8 = 0 ;
  SpiceChar *buffer10 = NULL ;
  size_t dim110 ;
  int alloc10 = 0 ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim18 = max(1, TIMELEN);
    buffer8 = (SpiceChar *) PyMem_Malloc((dim18 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("et2lst");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc8 = SWIG_NEWOBJ;
    
    buffer8[0] = '\0';   // String begins empty
    arg9 = buffer8;                                                // STRING
    arg8 = (SpiceInt)dim18;                                         // DIM1
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim110 = max(1, 10);
    buffer10 = (SpiceChar *) PyMem_Malloc((dim110 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("et2lst");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc10 = SWIG_NEWOBJ;
    
    buffer10[0] = '\0';   // String begins empty
    arg11 = buffer10;                                                // STRING
    arg10 = (SpiceInt)dim110;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "et2lst", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "et2lst" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "et2lst" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "et2lst" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("et2lst");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("et2lst");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_et2lst_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("et2lst");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer8[dim18-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer8);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer10[dim110-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer10);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc8)) {
      PyMem_Free((void *) buffer8);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc10)) {
      PyMem_Free((void *) buffer10);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc8)) {
      PyMem_Free((void *) buffer8);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc10)) {
      PyMem_Free((void *) buffer10);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_et2utc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, TIMELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("et2utc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "et2utc", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "et2utc" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("et2utc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("et2utc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "et2utc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  et2utc_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("et2utc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_etcal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, TIMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("etcal");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "etcal" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  etcal_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("etcal");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eul2m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble (*arg7)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("eul2m");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg7 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr7);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr7, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "eul2m", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "eul2m" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eul2m" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eul2m" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "eul2m" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "eul2m" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "eul2m" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  eul2m_c(arg1,arg2,arg3,arg4,arg5,arg6,(SpiceDouble (*)[3])arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eul2m");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eul2m_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceInt arg7 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[3] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
    arg13 = &dimsize10[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "eul2m_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("eul2m_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("eul2m_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("eul2m_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "eul2m_vector" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[4], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "eul2m_vector" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[5], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "eul2m_vector" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  eul2m_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eul2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("eul2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize10[0], dimsize10[1], dimsize10[2]
    };
    if (dims[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("eul2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eul2xf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceDouble (*arg5)[6] ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("eul2xf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "eul2xf", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("eul2xf", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("eul2xf", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eul2xf" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "eul2xf" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "eul2xf" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  eul2xf_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[6])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eul2xf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_eul2xf_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "eul2xf_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("eul2xf_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "eul2xf_vector" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "eul2xf_vector" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "eul2xf_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  eul2xf_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eul2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("eul2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("eul2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_expool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceBoolean *arg2 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceBoolean mybool2 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg2 = &mybool2;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("expool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("expool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  expool_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("expool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg2 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_failed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "failed", 0, 0, 0)) SWIG_fail;
  result = failed_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("failed");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fovray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "fovray", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("fovray", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("fovray", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "fovray" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_SpiceBoolean, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "fovray" "', argument " "7"" of type '" "SpiceBoolean *""'"); 
  }
  arg7 = (SpiceBoolean *)(argp7);
  my_fovray_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("fovray");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fovray_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceBoolean **arg10 = (SpiceBoolean **) 0 ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceBoolean *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "fovray_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("fovray_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr2) == 1) {
      arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                    // ARRAY
      arg3 = 0;                                                 // DIM1
      arg4 = (int) PyArray_DIM(pyarr2, 0);                        // DIM2
    } else {
      arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                    // ARRAY
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
      arg4 = (int) PyArray_DIM(pyarr2, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("fovray_vector", NPY_DOUBLE, swig_obj[5], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  fovray_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("fovray_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceBoolean));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("fovray_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_fovtrg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg7 ;
  SpiceBoolean *arg8 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[8] ;
  
  if (!SWIG_Python_UnpackTuple(args, "fovtrg", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "fovtrg" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SpiceBoolean, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "fovtrg" "', argument " "8"" of type '" "SpiceBoolean *""'"); 
  }
  arg8 = (SpiceBoolean *)(argp8);
  my_fovtrg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("fovtrg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_fovtrg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceBoolean **arg9 = (SpiceBoolean **) 0 ;
  int *arg10 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceBoolean *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[7] ;
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "fovtrg_vector", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("fovtrg_vector", NPY_DOUBLE, swig_obj[6], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  fovtrg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("fovtrg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceBoolean));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("fovtrg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_frame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("frame");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("frame");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("frame");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (SpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("frame", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("frame", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  my_frame_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frame");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_frame_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (SpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("frame_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  frame_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("frame_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_frinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "frinfo" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  frinfo_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_frmchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[6] ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("frmchg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "frmchg", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "frmchg" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "frmchg" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "frmchg" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  my_frmchg(arg1,arg2,arg3,(SpiceDouble (*)[6])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frmchg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_frmchg_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "frmchg_", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "frmchg_" "', argument " "1"" of type '" "SpiceInt *""'"); 
  }
  arg1 = (SpiceInt *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "frmchg_" "', argument " "2"" of type '" "SpiceInt *""'"); 
  }
  arg2 = (SpiceInt *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "frmchg_" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "frmchg_" "', argument " "4"" of type '" "SpiceDouble *""'"); 
  }
  arg4 = (SpiceDouble *)(argp4);
  frmchg_(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_frmchg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "frmchg_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "frmchg_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "frmchg_vector" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("frmchg_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  frmchg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frmchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("frmchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("frmchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_frmnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("frmnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "frmnam" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  frmnam_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("frmnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_furnsh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("furnsh");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("furnsh");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  furnsh_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("furnsh");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gcpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  char (*arg6)[KERVALLEN] ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *buffer3 ;
  int dimsize3[2] ;
  PyObject *list3 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize3[0] = KERVALS;                                       // ARRAY_dim0
    dimsize3[1] = KERVALLEN;                                       // NARRAY_dim1
    if (dimsize3[1] < 2) {
      dimsize3[1] = 2;
    }
    
    buffer3 = (char *) PyMem_Malloc(dimsize3[0] * dimsize3[1] * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("gcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = buffer3;                                                // ARRAY
    arg3 = dimsize3[0];                                            // DIM1
    arg4 = dimsize3[1];                                            // DIM2
    arg5 = &dimsize3[0];                                           // NSTRINGS
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "gcpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gcpool" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  gcpool_c(arg1,arg2,arg3,arg4,arg5,(char (*)[KERVALLEN])arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list3 = PyList_New(dimsize3[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list3)) {
        handle_malloc_failure("gcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize3[0]; i++) {
      char *str = &buffer3[i * dimsize3[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("gcpool");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list3, i, value);
    }
    list3 = Py_BuildValue("[N]", list3);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list3);
    list3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gdpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      KERVALS
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("gdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg4 = &size3[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "gdpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gdpool" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  gdpool_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_georec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("georec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "georec", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "georec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "georec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "georec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "georec" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "georec" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  georec_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("georec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_georec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "georec_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("georec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("georec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("georec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("georec_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("georec_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  georec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("georec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("georec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("georec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_getfov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceDouble *arg6 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceDouble (*arg9)[3] ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("getfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, NAMELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("getfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("getfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (int *SIZE1, int *SIZE2, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      FOVSHAPE, 3
    };                      // ARRAY
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("getfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize7[0] = (int) dims[0];
    dimsize7[1] = (int) dims[1];
    
    arg9 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr7);                                // ARRAY
    //  $4 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $5 = (int) PyArray_DIM(pyarr7, 1);                            // DIM2
    arg7 = &dimsize7[0];                                           // SIZE1
    //  arg8 = &dimsize7[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getfov" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_getfov_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(SpiceDouble (*)[3])arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("getfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr7, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_getmsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, LONGMSGLEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("getmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("getmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("getmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_getmsg_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("getmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gipool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int *SIZE1, SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      KERVALS
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("gipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceInt *) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg4 = &size3[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "gipool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gipool" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  gipool_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gnpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  char (*arg6)[NAMELEN] ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  char *buffer3 ;
  int dimsize3[2] ;
  PyObject *list3 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize3[0] = KERVALS;                                       // ARRAY_dim0
    dimsize3[1] = NAMELEN;                                       // NARRAY_dim1
    if (dimsize3[1] < 2) {
      dimsize3[1] = 2;
    }
    
    buffer3 = (char *) PyMem_Malloc(dimsize3[0] * dimsize3[1] * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("gnpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = buffer3;                                                // ARRAY
    arg3 = dimsize3[0];                                            // DIM1
    arg4 = dimsize3[1];                                            // DIM2
    arg5 = &dimsize3[0];                                           // NSTRINGS
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "gnpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gnpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gnpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gnpool" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  gnpool_c(arg1,arg2,arg3,arg4,arg5,(char (*)[NAMELEN])arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gnpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list3 = PyList_New(dimsize3[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list3)) {
        handle_malloc_failure("gnpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize3[0]; i++) {
      char *str = &buffer3[i * dimsize3[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("gnpool");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list3, i, value);
    }
    list3 = Py_BuildValue("[N]", list3);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list3);
    list3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_halfpi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "halfpi", 0, 0, 0)) SWIG_fail;
  result = halfpi_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("halfpi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ident(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble (*arg1)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr1 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr1)) {
        handle_malloc_failure("ident");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg1 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr1);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "ident", 0, 0, 0)) SWIG_fail;
  ident_c((SpiceDouble (*)[3])arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ident");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr1);
    // AppendOutput steals the reference to the argument.
    pyarr1 = NULL;
  }
  {
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "illum", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "illum" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("illum", NPY_DOUBLE, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 0) != (3))) {
        handle_invalid_array_shape_1d("illum", pyarr5, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  illum_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illum_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "illum_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("illum_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("illum_vector", NPY_DOUBLE, swig_obj[4], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr6) == 1) {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = 0;                                                 // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 0);                        // DIM2
    } else {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 1);                        // DIM2
    }
  }
  illum_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illum_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illum_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("illum_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceDouble));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illum_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illumf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  SpiceDouble *arg9 = (SpiceDouble *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  SpiceDouble *arg12 = (SpiceDouble *) 0 ;
  SpiceDouble *arg13 = (SpiceDouble *) 0 ;
  SpiceBoolean *arg14 = (SpiceBoolean *) 0 ;
  SpiceBoolean *arg15 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  SpiceDouble temp12 ;
  int res12 = SWIG_TMPOBJ ;
  SpiceDouble temp13 ;
  int res13 = SWIG_TMPOBJ ;
  SpiceBoolean mybool14 ;
  SpiceBoolean mybool15 ;
  PyObject *swig_obj[8] ;
  
  arg9 = &temp9;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  arg12 = &temp12;
  arg13 = &temp13;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg14 = &mybool14;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg15 = &mybool15;
  }
  if (!SWIG_Python_UnpackTuple(args, "illumf", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "illumf" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("illumf", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("illumf", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  illumf_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illumf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg12)));
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res13)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg13)));
  } else {
    int new_flags = SWIG_IsNewObj(res13) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg13), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg14 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg15 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illumf_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  SpiceDouble **arg19 = (SpiceDouble **) 0 ;
  int *arg20 = (int *) 0 ;
  SpiceDouble **arg21 = (SpiceDouble **) 0 ;
  int *arg22 = (int *) 0 ;
  SpiceBoolean **arg23 = (SpiceBoolean **) 0 ;
  int *arg24 = (int *) 0 ;
  SpiceBoolean **arg25 = (SpiceBoolean **) 0 ;
  int *arg26 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[2] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[1] ;
  PyArrayObject *pyarr19 = NULL ;
  SpiceDouble *buffer19 = NULL ;
  int dimsize19[1] ;
  PyArrayObject *pyarr21 = NULL ;
  SpiceDouble *buffer21 = NULL ;
  int dimsize21[1] ;
  PyArrayObject *pyarr23 = NULL ;
  SpiceBoolean *buffer23 = NULL ;
  int dimsize23[1] ;
  PyArrayObject *pyarr25 = NULL ;
  SpiceBoolean *buffer25 = NULL ;
  int dimsize25[1] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
    arg16 = &dimsize14[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg19 = &buffer19;                                               // ARRAY
    arg20 = &dimsize19[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg21 = &buffer21;                                               // ARRAY
    arg22 = &dimsize21[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg23 = &buffer23;                                               // ARRAY
    arg24 = &dimsize23[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg25 = &buffer25;                                               // ARRAY
    arg26 = &dimsize25[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "illumf_vector", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("illumf_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("illumf_vector", NPY_DOUBLE, swig_obj[7], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr9) == 1) {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = 0;                                                 // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 0);                        // DIM2
    } else {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 1);                        // DIM2
    }
  }
  illumf_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize14[0], dimsize14[1]
    };
    if (dimsize14[0] == 0) {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14,
      PyArray_SIZE(pyarr14) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize17[0], 1);
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17, dim * sizeof(SpiceDouble));
    if (dimsize17[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr17, PyArray_DATA(pyarr17));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr17 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr17);
      // AppendOutput steals the reference to the argument.
      pyarr17 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer19)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize19[0], 1);
    pyarr19 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr19)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr19), buffer19, dim * sizeof(SpiceDouble));
    if (dimsize19[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr19, PyArray_DATA(pyarr19));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr19 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr19);
      // AppendOutput steals the reference to the argument.
      pyarr19 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer21)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize21[0], 1);
    pyarr21 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr21)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr21), buffer21, dim * sizeof(SpiceDouble));
    if (dimsize21[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr21, PyArray_DATA(pyarr21));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr21 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr21);
      // AppendOutput steals the reference to the argument.
      pyarr21 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer23)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize23[0], 1);
    pyarr23 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr23)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr23), buffer23, dim * sizeof(SpiceBoolean));
    if (dimsize23[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr23, PyArray_DATA(pyarr23));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr23 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr23);
      // AppendOutput steals the reference to the argument.
      pyarr23 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer25)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize25[0], 1);
    pyarr25 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr25)) {
        handle_malloc_failure("illumf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr25), buffer25, dim * sizeof(SpiceBoolean));
    if (dimsize25[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr25, PyArray_DATA(pyarr25));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumf_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr25 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr25);
      // AppendOutput steals the reference to the argument.
      pyarr25 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  {
    Py_XDECREF(pyarr23);
    PyMem_Free((void *) buffer23);
  }
  {
    Py_XDECREF(pyarr25);
    PyMem_Free((void *) buffer25);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  {
    Py_XDECREF(pyarr23);
    PyMem_Free((void *) buffer23);
  }
  {
    Py_XDECREF(pyarr25);
    PyMem_Free((void *) buffer25);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illumg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  SpiceDouble *arg9 = (SpiceDouble *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  SpiceDouble *arg12 = (SpiceDouble *) 0 ;
  SpiceDouble *arg13 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  SpiceDouble temp12 ;
  int res12 = SWIG_TMPOBJ ;
  SpiceDouble temp13 ;
  int res13 = SWIG_TMPOBJ ;
  PyObject *swig_obj[8] ;
  
  arg9 = &temp9;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  arg12 = &temp12;
  arg13 = &temp13;
  if (!SWIG_Python_UnpackTuple(args, "illumg", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "illumg" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("illumg", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("illumg", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  illumg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illumg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg12)));
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res13)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg13)));
  } else {
    int new_flags = SWIG_IsNewObj(res13) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg13), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_illumg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  SpiceDouble **arg19 = (SpiceDouble **) 0 ;
  int *arg20 = (int *) 0 ;
  SpiceDouble **arg21 = (SpiceDouble **) 0 ;
  int *arg22 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[2] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[1] ;
  PyArrayObject *pyarr19 = NULL ;
  SpiceDouble *buffer19 = NULL ;
  int dimsize19[1] ;
  PyArrayObject *pyarr21 = NULL ;
  SpiceDouble *buffer21 = NULL ;
  int dimsize21[1] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
    arg16 = &dimsize14[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg19 = &buffer19;                                               // ARRAY
    arg20 = &dimsize19[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg21 = &buffer21;                                               // ARRAY
    arg22 = &dimsize21[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "illumg_vector", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("illumg_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("illumg_vector", NPY_DOUBLE, swig_obj[7], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr9) == 1) {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = 0;                                                 // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 0);                        // DIM2
    } else {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 1);                        // DIM2
    }
  }
  illumg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize14[0], dimsize14[1]
    };
    if (dimsize14[0] == 0) {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14,
      PyArray_SIZE(pyarr14) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize17[0], 1);
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17, dim * sizeof(SpiceDouble));
    if (dimsize17[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr17, PyArray_DATA(pyarr17));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr17 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr17);
      // AppendOutput steals the reference to the argument.
      pyarr17 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer19)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize19[0], 1);
    pyarr19 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr19)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr19), buffer19, dim * sizeof(SpiceDouble));
    if (dimsize19[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr19, PyArray_DATA(pyarr19));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr19 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr19);
      // AppendOutput steals the reference to the argument.
      pyarr19 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer21)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize21[0], 1);
    pyarr21 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr21)) {
        handle_malloc_failure("illumg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr21), buffer21, dim * sizeof(SpiceDouble));
    if (dimsize21[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr21, PyArray_DATA(pyarr21));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("illumg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr21 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr21);
      // AppendOutput steals the reference to the argument.
      pyarr21 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ilumin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  SpiceDouble *arg9 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  SpiceDouble *arg12 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble temp10 ;
  int res10 = SWIG_TMPOBJ ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  SpiceDouble temp12 ;
  int res12 = SWIG_TMPOBJ ;
  PyObject *swig_obj[7] ;
  
  arg8 = &temp8;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  arg11 = &temp11;
  arg12 = &temp12;
  if (!SWIG_Python_UnpackTuple(args, "ilumin", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ilumin" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ilumin", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 0) != (3))) {
        handle_invalid_array_shape_1d("ilumin", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  ilumin_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ilumin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg12)));
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ilumin_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  SpiceDouble **arg18 = (SpiceDouble **) 0 ;
  int *arg19 = (int *) 0 ;
  SpiceDouble **arg20 = (SpiceDouble **) 0 ;
  int *arg21 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyArrayObject *pyarr18 = NULL ;
  SpiceDouble *buffer18 = NULL ;
  int dimsize18[1] ;
  PyArrayObject *pyarr20 = NULL ;
  SpiceDouble *buffer20 = NULL ;
  int dimsize20[1] ;
  PyObject *swig_obj[7] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg18 = &buffer18;                                               // ARRAY
    arg19 = &dimsize18[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg20 = &buffer20;                                               // ARRAY
    arg21 = &dimsize20[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ilumin_vector", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("ilumin_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("ilumin_vector", NPY_DOUBLE, swig_obj[6], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  ilumin_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ilumin_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ilumin_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer18)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize18[0], 1);
    pyarr18 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr18)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr18), buffer18, dim * sizeof(SpiceDouble));
    if (dimsize18[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr18, PyArray_DATA(pyarr18));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ilumin_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr18 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr18);
      // AppendOutput steals the reference to the argument.
      pyarr18 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer20)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize20[0], 1);
    pyarr20 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr20)) {
        handle_malloc_failure("ilumin_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr20), buffer20, dim * sizeof(SpiceDouble));
    if (dimsize20[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr20, PyArray_DATA(pyarr20));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ilumin_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr20 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr20);
      // AppendOutput steals the reference to the argument.
      pyarr20 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inedpl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NELLIPSE
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("inedpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "inedpl", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "inedpl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "inedpl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "inedpl" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("inedpl", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("inedpl", pyarr4, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  inedpl_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inedpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inedpl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceBoolean **arg13 = (SpiceBoolean **) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceBoolean *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "inedpl_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("inedpl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("inedpl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("inedpl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("inedpl_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  inedpl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inedpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("inedpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("inedpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("inedpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("inedpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceBoolean));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("inedpl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inelpl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("inelpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("inelpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "inelpl", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("inelpl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NELLIPSE))) {
        handle_invalid_array_shape_1d("inelpl", pyarr1, NELLIPSE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("inelpl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("inelpl", pyarr2, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  inelpl_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inelpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inelpl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceInt **arg7 = (SpiceInt **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceInt *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "inelpl_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("inelpl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("inelpl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  inelpl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceInt));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("inelpl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("inelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inrypl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("inrypl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "inrypl", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("inrypl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("inrypl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("inrypl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("inrypl", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("inrypl", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("inrypl", pyarr3, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  inrypl_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inrypl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_inrypl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceInt **arg10 = (SpiceInt **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceInt *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "inrypl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("inrypl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("inrypl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("inrypl_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  inrypl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("inrypl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("inrypl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("inrypl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceInt));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("inrypl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("inrypl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("inrypl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_intmax(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "intmax", 0, 0, 0)) SWIG_fail;
  result = intmax_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("intmax");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_intmin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "intmin", 0, 0, 0)) SWIG_fail;
  result = intmin_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("intmin");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble (*arg2)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("invert");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invert", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("invert", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  invert_c((ConstSpiceDouble (*)[3])arg1,(SpiceDouble (*)[3])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invert");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_invert_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invert_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  invert_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invert_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("invert_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("invert_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_invort(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble (*arg2)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("invort");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invort", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("invort", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  invort_c((ConstSpiceDouble (*)[3])arg1,(SpiceDouble (*)[3])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invort");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_invort_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invort_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  invort_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invort_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("invort_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("invort_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isrot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "isrot", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("isrot", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("isrot", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isrot" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "isrot" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  result = isrot_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isrot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isrot_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceBoolean **arg9 = (SpiceBoolean **) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceBoolean *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "isrot_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("isrot_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("isrot_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("isrot_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  isrot_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("isrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("isrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceBoolean));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("isrot_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_j1900(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "j1900", 0, 0, 0)) SWIG_fail;
  result = j1900_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("j1900");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_j1950(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "j1950", 0, 0, 0)) SWIG_fail;
  result = j1950_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("j1950");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_j2000(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "j2000", 0, 0, 0)) SWIG_fail;
  result = j2000_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("j2000");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_j2100(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "j2100", 0, 0, 0)) SWIG_fail;
  result = j2100_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("j2100");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_jyear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "jyear", 0, 0, 0)) SWIG_fail;
  result = jyear_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("jyear");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kplfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("kplfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kplfrm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_kplfrm_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("kplfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_latcyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "latcyl", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "latcyl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "latcyl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "latcyl" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  latcyl_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latcyl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_latcyl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "latcyl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("latcyl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("latcyl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("latcyl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  latcyl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("latcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_latrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("latrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "latrec", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "latrec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "latrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "latrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  latrec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_latrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "latrec_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("latrec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("latrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("latrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  latrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("latrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("latrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_latsrf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble (*arg5)[2] ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "latsrf", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "latsrf" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY2[][ANY], int DIM1)
    //      (ConstSpiceDouble IN_ARRAY2[][ANY], SpiceInt DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("latsrf", NPY_DOUBLE, swig_obj[4], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 1) != (2))) {
        handle_invalid_array_shape_x2d("latsrf", pyarr5, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr5);                                // ARRAY
    arg6 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
  }
  my_latsrf_c(arg1,arg2,arg3,arg4,(ConstSpiceDouble (*)[2])arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("latsrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_latsph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "latsph", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "latsph" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "latsph" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "latsph" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  latsph_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latsph");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_latsph_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "latsph_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("latsph_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("latsph_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("latsph_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  latsph_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("latsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("latsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ldpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ldpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ldpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ldpool_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ldpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_limbpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  SpiceDouble arg9 ;
  SpiceInt arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceInt arg13 ;
  SpiceInt **arg14 = (SpiceInt **) 0 ;
  SpiceInt *arg15 = (SpiceInt *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  int *arg18 = (int *) 0 ;
  SpiceDouble **arg19 = (SpiceDouble **) 0 ;
  int *arg20 = (int *) 0 ;
  SpiceDouble **arg21 = (SpiceDouble **) 0 ;
  int *arg22 = (int *) 0 ;
  int *arg23 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceInt *buffer14 = NULL ;
  int dimsize14[1] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[2] ;
  PyArrayObject *pyarr19 = NULL ;
  SpiceDouble *buffer19 = NULL ;
  int dimsize19[1] ;
  PyArrayObject *pyarr21 = NULL ;
  SpiceDouble *buffer21 = NULL ;
  int dimsize21[2] ;
  PyObject *swig_obj[13] ;
  
  {
    //      (SpiceInt **OUT_ARRAY1, int *SIZE1)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
    arg18 = &dimsize16[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg19 = &buffer19;                                               // ARRAY
    arg20 = &dimsize19[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg21 = &buffer21;                                               // ARRAY
    arg22 = &dimsize21[0];                                           // SIZE1
    arg23 = &dimsize21[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "limbpt", 13, 13, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "limbpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("limbpt", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("limbpt", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "limbpt" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "limbpt" "', argument " "10"" of type '" "SpiceInt""'");
  } 
  arg10 = (SpiceInt)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "limbpt" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "limbpt" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "limbpt" "', argument " "13"" of type '" "SpiceInt""'");
  } 
  arg13 = (SpiceInt)(val13);
  my_limbpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceInt **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize14[0]
    };
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14, dims[0] * sizeof(SpiceInt));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize16[0], dimsize16[1]
    };
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16,
      PyArray_SIZE(pyarr16) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr16);
    // AppendOutput steals the reference to the argument.
    pyarr16 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer19)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize19[0]
    };
    pyarr19 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr19)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr19), buffer19, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr19);
    // AppendOutput steals the reference to the argument.
    pyarr19 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer21)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize21[0], dimsize21[1]
    };
    pyarr21 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr21)) {
        handle_malloc_failure("limbpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr21), buffer21,
      PyArray_SIZE(pyarr21) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr21);
    // AppendOutput steals the reference to the argument.
    pyarr21 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr19);
    PyMem_Free((void *) buffer19);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lspcn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "lspcn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lspcn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lspcn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lspcn" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("lspcn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lspcn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = lspcn_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lspcn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lspcn_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "lspcn_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("lspcn_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  lspcn_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize5[0], 1);
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("lspcn_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dim * sizeof(SpiceDouble));
    if (dimsize5[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr5, PyArray_DATA(pyarr5));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lspcn_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr5 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
      // AppendOutput steals the reference to the argument.
      pyarr5 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "ltime", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ltime" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ltime" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("ltime");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ltime");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ltime" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ltime_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ltime");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ltime_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ltime_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ltime_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ltime_vector" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ltime_vector" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ltime_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ltime_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("ltime_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ltime_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2eul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "m2eul", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("m2eul", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("m2eul", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "m2eul" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "m2eul" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "m2eul" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  m2eul_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("m2eul");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2eul_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceInt arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "m2eul_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("m2eul_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  ecode5 = SWIG_AsVal_int(swig_obj[1], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "m2eul_vector" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[2], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "m2eul_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "m2eul_vector" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  m2eul_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("m2eul_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("m2eul_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("m2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("m2eul_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2q(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      4
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("m2q");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("m2q", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("m2q", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  m2q_c((ConstSpiceDouble (*)[3])arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("m2q");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_m2q_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("m2q_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  m2q_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("m2q_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("m2q_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    if (dimsize5[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("m2q_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mequ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble (*arg2)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("mequ");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mequ", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mequ", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  mequ_c((ConstSpiceDouble (*)[3])arg1,(SpiceDouble (*)[3])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mequ");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mequ_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mequ_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  mequ_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("mequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("mequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mequg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mequg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  my_mequg_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("mequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("mequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mequg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mequg_nomalloc", 6, 6, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "my_mequg_nomalloc" "', argument " "1"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg1 = (ConstSpiceDouble *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "my_mequg_nomalloc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "my_mequg_nomalloc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_mequg_nomalloc" "', argument " "4"" of type '" "SpiceDouble *""'"); 
  }
  arg4 = (SpiceDouble *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "my_mequg_nomalloc" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_mequg_nomalloc" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  my_mequg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mequg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mequg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  mequg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("mequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("mequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceDouble (*arg3)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("mtxm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxm", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxm", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mtxm", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("mtxm", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3) || PyArray_DIM(pyarr2, 1) != (3))) {
        handle_invalid_array_shape_2d("mtxm", pyarr2, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                            // DIM2
  }
  mtxm_c((ConstSpiceDouble (*)[3])arg1,(ConstSpiceDouble (*)[3])arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxm_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxm_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mtxm_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mtxm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mtxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mtxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxmg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxmg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxmg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("mtxmg", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  my_mtxmg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("mtxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("mtxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mtxmg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mtxmg_nomalloc", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_mtxmg_nomalloc", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("my_mtxmg_nomalloc", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  res7 = SWIG_ConvertPtr(swig_obj[2], &argp7,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_mtxmg_nomalloc" "', argument " "7"" of type '" "SpiceDouble *""'"); 
  }
  arg7 = (SpiceDouble *)(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[3], &argp8,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "my_mtxmg_nomalloc" "', argument " "8"" of type '" "SpiceInt *""'"); 
  }
  arg8 = (SpiceInt *)(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[4], &argp9,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "my_mtxmg_nomalloc" "', argument " "9"" of type '" "SpiceInt *""'"); 
  }
  arg9 = (SpiceInt *)(argp9);
  my_mtxmg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxmg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxmg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxmg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mtxmg_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mtxmg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mtxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mtxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("mtxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxv", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxv", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mtxv", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("mtxv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("mtxv", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  mtxv_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxv_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxv_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mtxv_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  mtxv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("mtxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("mtxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxvg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxvg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("mtxvg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  my_mtxvg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("mtxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize6[0]
    };
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("mtxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mtxvg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  int *arg7 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mtxvg_nomalloc", 7, 7, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "my_mtxvg_nomalloc" "', argument " "1"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg1 = (ConstSpiceDouble *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "my_mtxvg_nomalloc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "my_mtxvg_nomalloc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_mtxvg_nomalloc" "', argument " "4"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg4 = (ConstSpiceDouble *)(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "my_mtxvg_nomalloc" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_mtxvg_nomalloc" "', argument " "6"" of type '" "SpiceDouble *""'"); 
  }
  arg6 = (SpiceDouble *)(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_mtxvg_nomalloc" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  my_mtxvg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_mtxvg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mtxvg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mtxvg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mtxvg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  mtxvg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mtxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("mtxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("mtxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceDouble (*arg3)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("mxm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxm", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxm", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mxm", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("mxm", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3) || PyArray_DIM(pyarr2, 1) != (3))) {
        handle_invalid_array_shape_2d("mxm", pyarr2, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                            // DIM2
  }
  mxm_c((ConstSpiceDouble (*)[3])arg1,(ConstSpiceDouble (*)[3])arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mxm_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxm_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxm_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mxm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mxm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("mxmg", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  my_mxmg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("mxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("mxmg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mxmg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mxmg_nomalloc", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_mxmg_nomalloc", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("my_mxmg_nomalloc", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  res7 = SWIG_ConvertPtr(swig_obj[2], &argp7,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_mxmg_nomalloc" "', argument " "7"" of type '" "SpiceDouble *""'"); 
  }
  arg7 = (SpiceDouble *)(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[3], &argp8,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "my_mxmg_nomalloc" "', argument " "8"" of type '" "SpiceInt *""'"); 
  }
  arg8 = (SpiceInt *)(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[4], &argp9,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "my_mxmg_nomalloc" "', argument " "9"" of type '" "SpiceInt *""'"); 
  }
  arg9 = (SpiceInt *)(argp9);
  my_mxmg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxmg_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mxmg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mxmg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceDouble (*arg3)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("mxmt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmt", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmt", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mxmt", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("mxmt", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3) || PyArray_DIM(pyarr2, 1) != (3))) {
        handle_invalid_array_shape_2d("mxmt", pyarr2, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                            // DIM2
  }
  mxmt_c((ConstSpiceDouble (*)[3])arg1,(ConstSpiceDouble (*)[3])arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmt_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmt_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxmt_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mxmt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mxmt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mxmt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmtg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmtg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmtg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("mxmtg", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  my_mxmtg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmtg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("mxmtg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("mxmtg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mxmtg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  void *argp9 = 0 ;
  int res9 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mxmtg_nomalloc", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_mxmtg_nomalloc", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("my_mxmtg_nomalloc", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    arg6 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
  }
  res7 = SWIG_ConvertPtr(swig_obj[2], &argp7,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_mxmtg_nomalloc" "', argument " "7"" of type '" "SpiceDouble *""'"); 
  }
  arg7 = (SpiceDouble *)(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[3], &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "my_mxmtg_nomalloc" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  res9 = SWIG_ConvertPtr(swig_obj[4], &argp9,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res9)) {
    SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "my_mxmtg_nomalloc" "', argument " "9"" of type '" "int *""'"); 
  }
  arg9 = (int *)(argp9);
  my_mxmtg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxmtg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "mxmtg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxmtg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxmtg_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 2) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 1);                        // DIM3
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
      arg8 = (int) PyArray_DIM(pyarr5, 2);                        // DIM3
    }
  }
  mxmtg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxmtg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("mxmtg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("mxmtg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("mxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "mxv", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxv", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("mxv", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("mxv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("mxv", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  mxv_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxv_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxv_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxv_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  mxv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("mxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("mxv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "mxvg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxvg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("mxvg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  my_mxvg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("mxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize6[0]
    };
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("mxvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_mxvg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_mxvg_nomalloc", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_mxvg_nomalloc", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("my_mxvg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    arg5 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  res6 = SWIG_ConvertPtr(swig_obj[2], &argp6,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_mxvg_nomalloc" "', argument " "6"" of type '" "SpiceDouble *""'"); 
  }
  arg6 = (SpiceDouble *)(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[3], &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_mxvg_nomalloc" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  my_mxvg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_mxvg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "mxvg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("mxvg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("mxvg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  mxvg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("mxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("mxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("mxvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_namfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("namfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("namfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  namfrm_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("namfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nearpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("nearpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "nearpt", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nearpt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("nearpt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nearpt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nearpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nearpt" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  nearpt_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nearpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nearpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "nearpt_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nearpt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("nearpt_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("nearpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("nearpt_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  nearpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nearpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("nearpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("nearpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("nearpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("nearpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceDouble));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("nearpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_npedln(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  ConstSpiceDouble *arg5 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("npedln");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "npedln", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "npedln" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "npedln" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "npedln" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("npedln", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("npedln", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("npedln", NPY_DOUBLE, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 0) != (3))) {
        handle_invalid_array_shape_1d("npedln", pyarr5, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  npedln_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("npedln");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_npedln_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  int arg12 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "npedln_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("npedln_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("npedln_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("npedln_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("npedln_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("npedln_vector", NPY_DOUBLE, swig_obj[4], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr10) == 1) {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = 0;                                                 // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 0);                        // DIM2
    } else {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 1);                        // DIM2
    }
  }
  npedln_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("npedln_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("npedln_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("npedln_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("npedln_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("npedln_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("npedln_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_npelpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("npelpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "npelpt", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("npelpt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("npelpt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("npelpt", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (NELLIPSE))) {
        handle_invalid_array_shape_1d("npelpt", pyarr2, NELLIPSE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  npelpt_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("npelpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_npelpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "npelpt_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("npelpt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("npelpt_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  npelpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("npelpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("npelpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("npelpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("npelpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("npelpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("npelpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nplnpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("nplnpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "nplnpt", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nplnpt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("nplnpt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("nplnpt", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("nplnpt", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("nplnpt", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("nplnpt", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  nplnpt_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nplnpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nplnpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "nplnpt_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nplnpt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("nplnpt_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("nplnpt_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  nplnpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nplnpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("nplnpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("nplnpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("nplnpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("nplnpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceDouble));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("nplnpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nvc2pl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NPLANE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("nvc2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "nvc2pl", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nvc2pl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("nvc2pl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nvc2pl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  nvc2pl_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nvc2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nvc2pl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "nvc2pl_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nvc2pl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("nvc2pl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  nvc2pl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nvc2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("nvc2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("nvc2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nvp2pl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NPLANE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("nvp2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "nvp2pl", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nvp2pl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("nvp2pl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("nvp2pl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("nvp2pl", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  nvp2pl_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nvp2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nvp2pl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "nvp2pl_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("nvp2pl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("nvp2pl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  nvp2pl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nvp2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("nvp2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("nvp2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_occult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg9 ;
  SpiceInt *arg10 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  SpiceInt temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyObject *swig_obj[9] ;
  
  arg10 = &temp10;
  if (!SWIG_Python_UnpackTuple(args, "occult", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "occult" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  occult_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("occult");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_occult_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  SpiceInt **arg11 = (SpiceInt **) 0 ;
  int *arg12 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceInt *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "occult_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("occult_vector", NPY_DOUBLE, swig_obj[8], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  occult_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("occult_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceInt));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("occult_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_oscelt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      8
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("oscelt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "oscelt", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("oscelt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("oscelt", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "oscelt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "oscelt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  oscelt_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("oscelt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_oscelt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "oscelt_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("oscelt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("oscelt_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("oscelt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  oscelt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("oscelt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("oscelt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("oscelt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_oscltx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_OSCLTX_NELTS
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("oscltx");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "oscltx", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("oscltx", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("oscltx", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "oscltx" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "oscltx" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  oscltx_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("oscltx");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_oscltx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "oscltx_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("oscltx_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("oscltx_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("oscltx_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  oscltx_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("oscltx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("oscltx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("oscltx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckcov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble (*arg3)[2] ;
  int *arg4 = (int *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int dimsize3[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("pckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize3[0] = (int) dims[0];
    dimsize3[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    arg4 = &dimsize3[0];                                           // SIZE1
    //  $5 = &dimsize3[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pckcov", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pckcov" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  my_pckcov_c(arg1,arg2,(SpiceDouble (*)[2])arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize3[0], dimsize3[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckfrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("pckfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pckfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_pckfrm_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckfrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pcpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pcpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("pcpool");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("pcpool");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("pcpool");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("pcpool");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  pcpool_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pcpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pdpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pdpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pdpool", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  pdpool_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pdpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pgrrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble *arg7 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pgrrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "pgrrec", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pgrrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pgrrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pgrrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pgrrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pgrrec" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pgrrec" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "pgrrec" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  pgrrec_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pgrrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pgrrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pgrrec_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pgrrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pgrrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pgrrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("pgrrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("pgrrec_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("pgrrec_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("pgrrec_vector", NPY_DOUBLE, swig_obj[5], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    if (PyArray_NDIM(pyarr10) == 0) {
      arg11 = 0;                                                 // DIM1
    } else {
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
    }
  }
  pgrrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pgrrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("pgrrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("pgrrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_phaseq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[5] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "phaseq", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "phaseq" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = phaseq_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("phaseq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_phaseq_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "phaseq_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("phaseq_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  phaseq_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("phaseq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("phaseq_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "pi", 0, 0, 0)) SWIG_fail;
  result = pi_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pipool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pipool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pipool", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  pipool_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pipool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pjelpl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NELLIPSE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("pjelpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "pjelpl", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pjelpl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NELLIPSE))) {
        handle_invalid_array_shape_1d("pjelpl", pyarr1, NELLIPSE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pjelpl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("pjelpl", pyarr2, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  pjelpl_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pjelpl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pjelpl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pjelpl_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pjelpl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("pjelpl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  pjelpl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pjelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pjelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pjelpl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceInt arg3 ;
  ConstSpiceInt (*arg4)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "pltar", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltar", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_x2d("pltar", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_INT, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pltar", NPY_INT, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (3))) {
        handle_invalid_array_shape_x2d("pltar", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceInt (*)[3]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  result = pltar_c(arg1,(ConstSpiceDouble (*)[3])arg2,arg3,(ConstSpiceInt (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltar");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltexp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble arg2 ;
  SpiceDouble (*arg3)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("pltexp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pltexp", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltexp", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("pltexp", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pltexp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  pltexp_c((ConstSpiceDouble (*)[3])arg1,arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltexp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltexp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "pltexp_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltexp_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("pltexp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  pltexp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltexp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pltexp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pltexp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltnp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("pltnp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "pltnp", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltnp", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnp", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pltnp", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnp", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pltnp", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnp", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("pltnp", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnp", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  pltnp_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltnp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltnp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  int arg12 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "pltnp_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltnp_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("pltnp_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("pltnp_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("pltnp_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr10) == 1) {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = 0;                                                 // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 0);                        // DIM2
    } else {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 1);                        // DIM2
    }
  }
  pltnp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltnp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("pltnp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("pltnp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("pltnp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("pltnp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("pltnp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltvol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceInt arg3 ;
  ConstSpiceInt (*arg4)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "pltvol", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltvol", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_x2d("pltvol", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_INT, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pltvol", NPY_INT, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (3))) {
        handle_invalid_array_shape_x2d("pltvol", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceInt (*)[3]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  result = pltvol_c(arg1,(ConstSpiceDouble (*)[3])arg2,arg3,(ConstSpiceInt (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltvol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2nvc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("pl2nvc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg3 = &temp3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2nvc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("pl2nvc", pyarr1, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  pl2nvc_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2nvc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2nvc_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2nvc_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  pl2nvc_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2nvc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("pl2nvc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pl2nvc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pl2nvc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pl2nvc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("pl2nvc_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2nvp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("pl2nvp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("pl2nvp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2nvp", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("pl2nvp", pyarr1, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  pl2nvp_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2nvp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2nvp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2nvp_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  pl2nvp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2nvp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("pl2nvp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pl2nvp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pl2nvp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pl2nvp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2psv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("pl2psv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("pl2psv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pl2psv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2psv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("pl2psv", pyarr1, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  pl2psv_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2psv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pl2psv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pl2psv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  pl2psv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("pl2psv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_prop2b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("prop2b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "prop2b", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "prop2b" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("prop2b", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("prop2b", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "prop2b" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  prop2b_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("prop2b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_prop2b_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "prop2b_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("prop2b_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("prop2b_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("prop2b_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  prop2b_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("prop2b_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("prop2b_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("prop2b_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_psv2pl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      NPLANE
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("psv2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "psv2pl", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("psv2pl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("psv2pl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("psv2pl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("psv2pl", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("psv2pl", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("psv2pl", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  psv2pl_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("psv2pl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_psv2pl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "psv2pl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("psv2pl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("psv2pl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("psv2pl_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  psv2pl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("psv2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("psv2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("psv2pl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pxform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pxform", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pxform" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  pxform_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pxform_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "pxform_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pxform_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  pxform_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("pxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pxfrm2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble (*arg5)[3] ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pxfrm2", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pxfrm2" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pxfrm2" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  pxfrm2_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[3])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pxfrm2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pxfrm2_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[3] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
    arg10 = &dimsize7[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "pxfrm2_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pxfrm2_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("pxfrm2_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  pxfrm2_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize7[0], dimsize7[1], dimsize7[2]
    };
    if (dims[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("pxfrm2_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_q2m(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble (*arg2)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("q2m");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("q2m", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (4))) {
        handle_invalid_array_shape_1d("q2m", pyarr1, 4);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  q2m_c(arg1,(SpiceDouble (*)[3])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("q2m");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_q2m_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
    arg7 = &dimsize4[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("q2m_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  q2m_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("q2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("q2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize4[0], dimsize4[1], dimsize4[2]
    };
    if (dims[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("q2m_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qcktrc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceChar *arg2 ;
  SpiceChar *buffer1 = NULL ;
  size_t dim11 ;
  int alloc1 = 0 ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim11 = max(1, LONGMSGLEN);
    buffer1 = (SpiceChar *) PyMem_Malloc((dim11 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer1)) {
        handle_malloc_failure("qcktrc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc1 = SWIG_NEWOBJ;
    
    buffer1[0] = '\0';   // String begins empty
    arg2 = buffer1;                                                // STRING
    arg1 = (SpiceInt)dim11;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "qcktrc", 0, 0, 0)) SWIG_fail;
  qcktrc_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qcktrc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer1[dim11-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer1);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc1)) {
      PyMem_Free((void *) buffer1);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc1)) {
      PyMem_Free((void *) buffer1);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qdq2av(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("qdq2av");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "qdq2av", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("qdq2av", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (4))) {
        handle_invalid_array_shape_1d("qdq2av", pyarr1, 4);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("qdq2av", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (4))) {
        handle_invalid_array_shape_1d("qdq2av", pyarr2, 4);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  qdq2av_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qdq2av");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qdq2av_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "qdq2av_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("qdq2av_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("qdq2av_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  qdq2av_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qdq2av_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("qdq2av_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("qdq2av_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qxq(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      4
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("qxq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "qxq", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("qxq", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (4))) {
        handle_invalid_array_shape_1d("qxq", pyarr1, 4);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("qxq", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (4))) {
        handle_invalid_array_shape_1d("qxq", pyarr2, 4);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  qxq_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qxq");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_qxq_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "qxq_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("qxq_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("qxq_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  qxq_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qxq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("qxq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("qxq_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_radrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("radrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "radrec", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "radrec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "radrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "radrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  radrec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("radrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_radrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "radrec_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("radrec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("radrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("radrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  radrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("radrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("radrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("radrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rav2xf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble (*arg3)[6] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("rav2xf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "rav2xf", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rav2xf", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("rav2xf", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("rav2xf", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("rav2xf", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  rav2xf_c((ConstSpiceDouble (*)[3])arg1,arg2,(SpiceDouble (*)[6])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rav2xf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rav2xf_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
    arg11 = &dimsize8[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "rav2xf_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rav2xf_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("rav2xf_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  rav2xf_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rav2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("rav2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize8[0], dimsize8[1], dimsize8[2]
    };
    if (dims[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("rav2xf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_raxisa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("raxisa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg3 = &temp3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("raxisa", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("raxisa", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  raxisa_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("raxisa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_raxisa_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[2] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("raxisa_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  raxisa_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("raxisa_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("raxisa_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    if (dimsize5[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("raxisa_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("raxisa_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("raxisa_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("raxisa_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reccyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reccyl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("reccyl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  reccyl_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reccyl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reccyl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reccyl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  reccyl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reccyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reccyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("reccyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reccyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recgeo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "recgeo", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recgeo", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("recgeo", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "recgeo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "recgeo" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  recgeo_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recgeo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "recgeo_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recgeo_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("recgeo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("recgeo_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  recgeo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recgeo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recgeo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("recgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recgeo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reclat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reclat", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("reclat", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  reclat_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reclat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reclat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reclat_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  reclat_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reclat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reclat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("reclat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reclat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recpgr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "recpgr", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("recpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("recpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("recpgr", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("recpgr", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "recpgr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "recpgr" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  recpgr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recpgr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recpgr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "recpgr_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("recpgr_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr2) == 1) {
      arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                    // ARRAY
      arg3 = 0;                                                 // DIM1
      arg4 = (int) PyArray_DIM(pyarr2, 0);                        // DIM2
    } else {
      arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                    // ARRAY
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
      arg4 = (int) PyArray_DIM(pyarr2, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("recpgr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("recpgr_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  recpgr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recpgr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recpgr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("recpgr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceDouble));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recpgr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recrad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recrad", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("recrad", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  recrad_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recrad");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recrad_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recrad_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  recrad_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recrad_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recrad_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("recrad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recrad_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recsph(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recsph", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("recsph", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  recsph_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recsph");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recsph_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recsph_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  recsph_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("recsph_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recsph_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_refchg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("refchg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "refchg", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "refchg" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "refchg" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "refchg" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  my_refchg(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("refchg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_refchg_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "refchg_", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "refchg_" "', argument " "1"" of type '" "SpiceInt *""'"); 
  }
  arg1 = (SpiceInt *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "refchg_" "', argument " "2"" of type '" "SpiceInt *""'"); 
  }
  arg2 = (SpiceInt *)(argp2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "refchg_" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "refchg_" "', argument " "4"" of type '" "SpiceDouble *""'"); 
  }
  arg4 = (SpiceDouble *)(argp4);
  refchg_(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_refchg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "refchg_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "refchg_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "refchg_vector" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("refchg_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  refchg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("refchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("refchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("refchg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  repmc_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar arg4 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim15 = max(1, MESSAGELEN);
    buffer5 = (SpiceChar *) PyMem_Malloc((dim15 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc5 = SWIG_NEWOBJ;
    
    buffer5[0] = '\0';   // String begins empty
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt)dim15;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmct", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repmct" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[3], &arg4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  repmct_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return resultobj;
fail:
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim15 = max(1, MESSAGELEN);
    buffer5 = (SpiceChar *) PyMem_Malloc((dim15 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc5 = SWIG_NEWOBJ;
    
    buffer5[0] = '\0';   // String begins empty
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt)dim15;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmd", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repmd" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "repmd" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  repmd_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  SpiceChar arg5 ;
  SpiceInt arg6 ;
  SpiceChar *arg7 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceChar *buffer6 = NULL ;
  size_t dim16 ;
  int alloc6 = 0 ;
  PyObject *swig_obj[5] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim16 = max(1, MESSAGELEN);
    buffer6 = (SpiceChar *) PyMem_Malloc((dim16 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc6 = SWIG_NEWOBJ;
    
    buffer6[0] = '\0';   // String begins empty
    arg7 = buffer6;                                                // STRING
    arg6 = (SpiceInt)dim16;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmf", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repmf" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "repmf" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[4], &arg5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  repmf_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer6[dim16-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer6);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc6)) {
      PyMem_Free((void *) buffer6);
    }
  }
  return resultobj;
fail:
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc6)) {
      PyMem_Free((void *) buffer6);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmi", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repmi" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  repmi_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repmot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar arg4 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim15 = max(1, MESSAGELEN);
    buffer5 = (SpiceChar *) PyMem_Malloc((dim15 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc5 = SWIG_NEWOBJ;
    
    buffer5[0] = '\0';   // String begins empty
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt)dim15;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repmot", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repmot" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[3], &arg4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  repmot_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repmot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return resultobj;
fail:
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reset(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "reset", 0, 0, 0)) SWIG_fail;
  my_reset_c();
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  SpiceDouble (*arg3)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("rotate");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "rotate", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rotate" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rotate" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  rotate_c(arg1,arg2,(SpiceDouble (*)[3])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotate");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotate_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  SpiceInt arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[3] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
    arg7 = &dimsize4[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "rotate_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rotate_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rotate_vector" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  rotate_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotate_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("rotate_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize4[0], dimsize4[1], dimsize4[2]
    };
    if (dims[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("rotate_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotmat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble arg2 ;
  SpiceInt arg3 ;
  SpiceDouble (*arg4)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("rotmat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "rotmat", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rotmat", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("rotmat", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rotmat" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rotmat" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  rotmat_c((ConstSpiceDouble (*)[3])arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotmat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotmat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceInt arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
    arg11 = &dimsize8[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "rotmat_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rotmat_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("rotmat_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[2], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "rotmat_vector" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  rotmat_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotmat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("rotmat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize8[0], dimsize8[1], dimsize8[2]
    };
    if (dims[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("rotmat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotvec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("rotvec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "rotvec", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rotvec", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("rotvec", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rotvec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rotvec" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  rotvec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotvec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rotvec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "rotvec_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rotvec_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("rotvec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  ecode6 = SWIG_AsVal_int(swig_obj[2], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "rotvec_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  rotvec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rotvec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("rotvec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("rotvec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "rpd", 0, 0, 0)) SWIG_fail;
  result = rpd_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rpd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_rquad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      2
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("rquad");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      2
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("rquad");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "rquad", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "rquad" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rquad" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rquad" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  rquad_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rquad");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_rquad_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "rquad_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("rquad_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("rquad_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("rquad_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  rquad_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("rquad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("rquad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("rquad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("rquad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("rquad_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_saelgv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("saelgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("saelgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "saelgv", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("saelgv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("saelgv", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("saelgv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("saelgv", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  saelgv_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("saelgv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_saelgv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "saelgv_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("saelgv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("saelgv_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  saelgv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("saelgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("saelgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("saelgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("saelgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("saelgv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_scdecd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, TIMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("scdecd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "scdecd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "scdecd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scdecd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  scdecd_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("scdecd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sce2c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "sce2c", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sce2c" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sce2c" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  sce2c_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sce2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sce2c_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sce2c_vector", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sce2c_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("sce2c_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  sce2c_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sce2c_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("sce2c_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("sce2c_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sce2c_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sce2s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, TIMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("sce2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "sce2s", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sce2s" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sce2s" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  sce2s_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sce2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sce2t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "sce2t", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sce2t" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sce2t" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  sce2t_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sce2t");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sce2t_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sce2t_vector", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sce2t_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("sce2t_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  sce2t_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sce2t_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("sce2t_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("sce2t_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sce2t_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_scencd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "scencd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "scencd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("scencd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("scencd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  scencd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("scencd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_scfmt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, TIMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("scfmt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "scfmt", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "scfmt" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scfmt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  scfmt_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("scfmt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_scpart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceDouble *arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyArrayObject *pyarr4 = NULL ;
  int size4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_SCLK_MXPART
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("scpart");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg2 = &size2[0];                                              // SIZE1
  }
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_SCLK_MXPART
    };                               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("scpart");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    arg4 = &size4[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "scpart" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_scpart_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("scpart");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size4[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_scs2e(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "scs2e", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "scs2e" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("scs2e");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("scs2e");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  scs2e_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("scs2e");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sct2e(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "sct2e", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sct2e" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sct2e" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  sct2e_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sct2e");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sct2e_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sct2e_vector", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sct2e_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("sct2e_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  sct2e_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sct2e_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("sct2e_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("sct2e_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sct2e_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sctiks(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "sctiks", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sctiks" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("sctiks");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sctiks");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  sctiks_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sctiks");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_setmsg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("setmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("setmsg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_setmsg_c(arg1);
  resultobj = SWIG_Py_Void();
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sigerr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("sigerr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sigerr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  sigerr_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,498,RAISE_SIGERR_EXCEPTION@*/{
      handle_sigerr_exception();
      SWIG_fail;
    }
    /*@SWIG@*/;
    Py_XDECREF(resultobj);
    resultobj = (Py_INCREF(Py_None), Py_None);
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sincpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  SpiceDouble *arg9 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  SpiceDouble *arg11 ;
  SpiceBoolean *arg12 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceBoolean mybool12 ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg11 = (SpiceDouble *) PyArray_DATA(pyarr11);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr11, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg12 = &mybool12;
  }
  if (!SWIG_Python_UnpackTuple(args, "sincpt", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sincpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("sincpt", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("sincpt", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  sincpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sincpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg12 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sincpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  SpiceDouble **arg15 = (SpiceDouble **) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  int *arg19 = (int *) 0 ;
  SpiceBoolean **arg20 = (SpiceBoolean **) 0 ;
  int *arg21 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyArrayObject *pyarr15 = NULL ;
  SpiceDouble *buffer15 = NULL ;
  int dimsize15[1] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[2] ;
  PyArrayObject *pyarr20 = NULL ;
  SpiceBoolean *buffer20 = NULL ;
  int dimsize20[1] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg15 = &buffer15;                                               // ARRAY
    arg16 = &dimsize15[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
    arg19 = &dimsize17[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg20 = &buffer20;                                               // ARRAY
    arg21 = &dimsize20[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sincpt_vector", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("sincpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("sincpt_vector", NPY_DOUBLE, swig_obj[7], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr9) == 1) {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = 0;                                                 // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 0);                        // DIM2
    } else {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 1);                        // DIM2
    }
  }
  sincpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize15[0], 1);
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr15), buffer15, dim * sizeof(SpiceDouble));
    if (dimsize15[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr15, PyArray_DATA(pyarr15));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sincpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr15 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
      // AppendOutput steals the reference to the argument.
      pyarr15 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize17[0], dimsize17[1]
    };
    if (dimsize17[0] == 0) {
      pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr17 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17,
      PyArray_SIZE(pyarr17) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr17);
    // AppendOutput steals the reference to the argument.
    pyarr17 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer20)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize20[0], 1);
    pyarr20 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr20)) {
        handle_malloc_failure("sincpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr20), buffer20, dim * sizeof(SpiceBoolean));
    if (dimsize20[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr20, PyArray_DATA(pyarr20));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sincpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr20 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr20);
      // AppendOutput steals the reference to the argument.
      pyarr20 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "spd", 0, 0, 0)) SWIG_fail;
  result = spd_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphcyl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "sphcyl", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sphcyl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sphcyl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sphcyl" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  sphcyl_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphcyl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphcyl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sphcyl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("sphcyl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("sphcyl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("sphcyl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  sphcyl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("sphcyl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphcyl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphlat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "sphlat", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sphlat" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sphlat" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sphlat" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  sphlat_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphlat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphlat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sphlat_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("sphlat_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("sphlat_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("sphlat_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  sphlat_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphlat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphlat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("sphlat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("sphlat_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("sphrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "sphrec", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "sphrec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sphrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sphrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  sphrec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sphrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "sphrec_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("sphrec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("sphrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("sphrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  sphrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sphrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("sphrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("sphrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkacs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "spkacs", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkacs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkacs" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkacs" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  spkacs_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkacs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkacs_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkacs_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkacs_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkacs_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkacs_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  spkacs_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkacs_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkacs_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkacs_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkapo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkapo", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkapo" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkapo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("spkapo", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (6))) {
        handle_invalid_array_shape_1d("spkapo", pyarr4, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkapo_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkapo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkapo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkapo_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkapo_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkapo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("spkapo_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkapo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkapo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkapo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkapp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkapp", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkapp" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkapp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("spkapp", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (6))) {
        handle_invalid_array_shape_1d("spkapp", pyarr4, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkapp_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkapp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkapp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkapp_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkapp_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkapp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("spkapp_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkapp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkapp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkapp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg5 ;
  ConstSpiceDouble *arg6 ;
  SpiceDouble *arg7 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  SpiceDouble *arg9 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  SpiceDouble temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg8 = &temp8;
  arg9 = &temp9;
  if (!SWIG_Python_UnpackTuple(args, "spkaps", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkaps" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkaps" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("spkaps", NPY_DOUBLE, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 0) != (6))) {
        handle_invalid_array_shape_1d("spkaps", pyarr5, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkaps", NPY_DOUBLE, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr6) && (PyArray_DIM(pyarr6, 0) != (3))) {
        handle_invalid_array_shape_1d("spkaps", pyarr6, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
  }
  spkaps_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkaps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkaps_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  int arg11 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  SpiceDouble **arg15 = (SpiceDouble **) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyArrayObject *pyarr15 = NULL ;
  SpiceDouble *buffer15 = NULL ;
  int dimsize15[1] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[1] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg15 = &buffer15;                                               // ARRAY
    arg16 = &dimsize15[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkaps_vector", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkaps_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkaps_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkaps_vector", NPY_DOUBLE, swig_obj[4], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr6) == 1) {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = 0;                                                 // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 0);                        // DIM2
    } else {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("spkaps_vector", NPY_DOUBLE, swig_obj[5], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr9) == 1) {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = 0;                                                 // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 0);                        // DIM2
    } else {
      arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                    // ARRAY
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
      arg11 = (int) PyArray_DIM(pyarr9, 1);                        // DIM2
    }
  }
  spkaps_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize15[0], 1);
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr15), buffer15, dim * sizeof(SpiceDouble));
    if (dimsize15[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr15, PyArray_DATA(pyarr15));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkaps_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr15 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
      // AppendOutput steals the reference to the argument.
      pyarr15 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize17[0], 1);
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("spkaps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17, dim * sizeof(SpiceDouble));
    if (dimsize17[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr17, PyArray_DATA(pyarr17));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkaps_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr17 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr17);
      // AppendOutput steals the reference to the argument.
      pyarr17 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble (*arg3)[2] ;
  int *arg4 = (int *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int dimsize3[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("spkcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize3[0] = (int) dims[0];
    dimsize3[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    arg4 = &dimsize3[0];                                           // SIZE1
    //  $5 = &dimsize3[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "spkcov", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkcov" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  my_spkcov_c(arg1,arg2,(SpiceDouble (*)[2])arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize3[0], dimsize3[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkez(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkez", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkez" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkez" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkez" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  spkez_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkez");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkez_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkez_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkez_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkez_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkez_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  spkez_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkez_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkez_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkezp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkezp", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkezp" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkezp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkezp" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  spkezp_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkezp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkezp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceInt arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkezp_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkezp_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkezp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkezp_vector" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  spkezp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkezp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkezp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkezr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkezr", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkezr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkezr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkezr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkezr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkezr_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkezr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkezr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkezr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkezr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkgeo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("spkgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "spkgeo", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkgeo" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkgeo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spkgeo" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  spkgeo_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkgeo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkgeo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkgeo_vector", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkgeo_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkgeo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkgeo_vector" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  spkgeo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkgeo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkgeo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkgps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("spkgps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "spkgps", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkgps" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkgps" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkgps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkgps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spkgps" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  spkgps_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkgps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkgps_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkgps_vector", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkgps_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkgps_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkgps_vector" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  spkgps_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkgps_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkgps_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkltc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg5 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "spkltc", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkltc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkltc" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("spkltc", NPY_DOUBLE, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 0) != (6))) {
        handle_invalid_array_shape_1d("spkltc", pyarr5, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  spkltc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkltc_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkltc_vector", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkltc_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkltc_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkltc_vector", NPY_DOUBLE, swig_obj[4], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr6) == 1) {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = 0;                                                 // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 0);                        // DIM2
    } else {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 1);                        // DIM2
    }
  }
  spkltc_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkltc_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize14[0], 1);
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("spkltc_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14, dim * sizeof(SpiceDouble));
    if (dimsize14[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr14, PyArray_DATA(pyarr14));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkltc_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr14 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr14);
      // AppendOutput steals the reference to the argument.
      pyarr14 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkobj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 ;
  int *arg3 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("spkobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_spkobj_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkpos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "spkpos", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkpos" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkpos_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkpos_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkpos_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkpos_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkpos_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkpos_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkpos_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkssb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("spkssb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkssb", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkssb" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkssb" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkssb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkssb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkssb_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkssb");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkssb_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "spkssb_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkssb_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkssb_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkssb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkssb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkssb_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkssb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("spkssb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    if (dimsize5[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("spkssb_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfc2s(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("srfc2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!SWIG_Python_UnpackTuple(args, "srfc2s", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "srfc2s" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "srfc2s" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  srfc2s_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfc2s");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfcss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("srfcss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!SWIG_Python_UnpackTuple(args, "srfcss", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "srfcss" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("srfcss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfcss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  srfcss_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfcss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfnrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  ConstSpiceDouble (*arg6)[3] ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "srfnrm", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "srfnrm" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("srfnrm", NPY_DOUBLE, swig_obj[4], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr5) && (PyArray_DIM(pyarr5, 1) != (3))) {
        handle_invalid_array_shape_x2d("srfnrm", pyarr5, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr5);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
  }
  my_srfnrm_c(arg1,arg2,arg3,arg4,arg5,(ConstSpiceDouble (*)[3])arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("srfnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("srfrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "srfrec", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "srfrec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "srfrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "srfrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  srfrec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "srfrec_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "srfrec_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("srfrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("srfrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  srfrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("srfrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("srfrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfs2c(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!SWIG_Python_UnpackTuple(args, "srfs2c", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("srfs2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfs2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("srfs2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfs2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  srfs2c_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfs2c");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfscc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!SWIG_Python_UnpackTuple(args, "srfscc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("srfscc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfscc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "srfscc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  srfscc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfscc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfxpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 ;
  SpiceDouble *arg8 ;
  SpiceDouble *arg9 = (SpiceDouble *) 0 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  SpiceDouble *arg11 ;
  SpiceBoolean *arg12 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble temp9 ;
  int res9 = SWIG_TMPOBJ ;
  SpiceDouble temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceBoolean mybool12 ;
  PyObject *swig_obj[7] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceDouble *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg9 = &temp9;
  arg10 = &temp10;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg11 = (SpiceDouble *) PyArray_DATA(pyarr11);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr11, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg12 = &mybool12;
  }
  if (!SWIG_Python_UnpackTuple(args, "srfxpt", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "srfxpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("srfxpt", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 0) != (3))) {
        handle_invalid_array_shape_1d("srfxpt", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  srfxpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfxpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg12 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_srfxpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  SpiceDouble **arg18 = (SpiceDouble **) 0 ;
  int *arg19 = (int *) 0 ;
  int *arg20 = (int *) 0 ;
  SpiceBoolean **arg21 = (SpiceBoolean **) 0 ;
  int *arg22 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[1] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyArrayObject *pyarr18 = NULL ;
  SpiceDouble *buffer18 = NULL ;
  int dimsize18[2] ;
  PyArrayObject *pyarr21 = NULL ;
  SpiceBoolean *buffer21 = NULL ;
  int dimsize21[1] ;
  PyObject *swig_obj[7] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg18 = &buffer18;                                               // ARRAY
    arg19 = &dimsize18[0];                                           // SIZE1
    arg20 = &dimsize18[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg21 = &buffer21;                                               // ARRAY
    arg22 = &dimsize21[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "srfxpt_vector", 7, 7, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("srfxpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("srfxpt_vector", NPY_DOUBLE, swig_obj[6], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  srfxpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize14[0], 1);
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14, dim * sizeof(SpiceDouble));
    if (dimsize14[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr14, PyArray_DATA(pyarr14));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("srfxpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr14 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr14);
      // AppendOutput steals the reference to the argument.
      pyarr14 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("srfxpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer18)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize18[0], dimsize18[1]
    };
    if (dimsize18[0] == 0) {
      pyarr18 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr18 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr18)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr18), buffer18,
      PyArray_SIZE(pyarr18) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr18);
    // AppendOutput steals the reference to the argument.
    pyarr18 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer21)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize21[0], 1);
    pyarr21 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr21)) {
        handle_malloc_failure("srfxpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr21), buffer21, dim * sizeof(SpiceBoolean));
    if (dimsize21[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr21, PyArray_DATA(pyarr21));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("srfxpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr21 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr21);
      // AppendOutput steals the reference to the argument.
      pyarr21 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr21);
    PyMem_Free((void *) buffer21);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stcf01(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "stcf01", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("stcf01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("stcf01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stcf01" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "stcf01" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "stcf01" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "stcf01" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  my_stcf01(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stcf01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_stcg01(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceChar *arg7 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceChar *buffer7 = NULL ;
  size_t dim17 = 0 ;
  int alloc7 = 0 ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  {
    //      (char OUT_STRING[ANY])
    
    dim17 = max(1, 20);
    buffer7 = (char *) PyMem_Malloc((dim17 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("stcg01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc7 = SWIG_NEWOBJ;
    
    buffer7[0] = '\0';   // String begins empty
    arg7 = buffer7;                                                // STRING
    //  $2 = dim17;                                                  // DIM1
  }
  arg8 = &temp8;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "stcg01" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_stcg01(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stcg01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer7[dim17-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer7);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc7)) {
      PyMem_Free((void *) buffer7);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc7)) {
      PyMem_Free((void *) buffer7);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stcl01(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceChar *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (char *) PyMem_Malloc((dim12 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("stcl01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg2 = buffer2;                                                // STRING
    //  $2 = dim12;                                                  // DIM1
  }
  arg3 = &temp3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "stcl01" "', argument " "1"" of type '" "ConstSpiceChar *""'"); 
  }
  arg1 = (ConstSpiceChar *)(argp1);
  my_stcl01(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stcl01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stelab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("stelab");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "stelab", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("stelab", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("stelab", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("stelab", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("stelab", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  stelab_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stelab");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stelab_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "stelab_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("stelab_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("stelab_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  stelab_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stelab_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("stelab_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("stelab_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stlabx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("stlabx");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "stlabx", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("stlabx", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("stlabx", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("stlabx", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("stlabx", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  stlabx_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stlabx");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stlabx_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "stlabx_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("stlabx_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("stlabx_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  stlabx_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("stlabx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("stlabx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("stlabx_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_stpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("stpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "stpool", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("stpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("stpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "stpool" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("stpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("stpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_stpool_c(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_str2et(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("str2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("str2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  str2et_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("str2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_subpnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg7 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  SpiceDouble *arg9 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr9 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg8 = &temp8;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "subpnt", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subpnt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subpnt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subpnt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "subpnt_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("subpnt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subpnt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("subpnt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("subpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "subpt", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "subpt_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("subpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("subpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("subpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subslr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg7 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  SpiceDouble *arg9 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr9 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg8 = &temp8;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "subslr", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subslr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subslr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subslr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subslr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "subslr_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("subslr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subslr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("subslr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("subslr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subsol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg6 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "subsol", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "subsol" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subsol_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subsol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_subsol_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "subsol_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("subsol_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  subsol_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("subsol_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_surfnm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("surfnm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "surfnm", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "surfnm" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "surfnm" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "surfnm" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("surfnm", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("surfnm", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  surfnm_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("surfnm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_surfpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("surfpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "surfpt", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("surfpt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("surfpt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("surfpt", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("surfpt", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "surfpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "surfpt" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "surfpt" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  surfpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("surfpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_surfpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int arg12 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceBoolean **arg16 = (SpiceBoolean **) 0 ;
  int *arg17 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceBoolean *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "surfpt_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("surfpt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("surfpt_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("surfpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("surfpt_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("surfpt_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
    if (PyArray_NDIM(pyarr11) == 0) {
      arg12 = 0;                                                 // DIM1
    } else {
      arg12 = (int) PyArray_DIM(pyarr11, 0);                        // DIM1
    }
  }
  surfpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("surfpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("surfpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("surfpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("surfpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("surfpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceBoolean));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("surfpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_surfpv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("surfpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "surfpv", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("surfpv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("surfpv", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("surfpv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (6))) {
        handle_invalid_array_shape_1d("surfpv", pyarr2, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "surfpv" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "surfpv" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "surfpv" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  surfpv_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("surfpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_surfpv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int arg12 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceBoolean **arg16 = (SpiceBoolean **) 0 ;
  int *arg17 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceBoolean *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "surfpv_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("surfpv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("surfpv_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("surfpv_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("surfpv_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("surfpv_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
    if (PyArray_NDIM(pyarr11) == 0) {
      arg12 = 0;                                                 // DIM1
    } else {
      arg12 = (int) PyArray_DIM(pyarr11, 0);                        // DIM1
    }
  }
  surfpv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("surfpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("surfpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("surfpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("surfpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("surfpv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceBoolean));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("surfpv_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sxform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[6] ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "sxform", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sxform" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  sxform_c(arg1,arg2,arg3,(SpiceDouble (*)[6])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sxform");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sxform_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "sxform_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("sxform_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  sxform_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("sxform_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_termpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 ;
  SpiceDouble arg10 ;
  SpiceInt arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceInt arg14 ;
  SpiceInt **arg15 = (SpiceInt **) 0 ;
  SpiceInt *arg16 = (SpiceInt *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  int *arg19 = (int *) 0 ;
  SpiceDouble **arg20 = (SpiceDouble **) 0 ;
  int *arg21 = (int *) 0 ;
  SpiceDouble **arg22 = (SpiceDouble **) 0 ;
  int *arg23 = (int *) 0 ;
  int *arg24 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  double val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyArrayObject *pyarr15 = NULL ;
  SpiceInt *buffer15 = NULL ;
  int dimsize15[1] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[2] ;
  PyArrayObject *pyarr20 = NULL ;
  SpiceDouble *buffer20 = NULL ;
  int dimsize20[1] ;
  PyArrayObject *pyarr22 = NULL ;
  SpiceDouble *buffer22 = NULL ;
  int dimsize22[2] ;
  PyObject *swig_obj[14] ;
  
  {
    //      (SpiceInt **OUT_ARRAY1, int *SIZE1)
    
    arg15 = &buffer15;                                               // ARRAY
    arg16 = &dimsize15[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
    arg19 = &dimsize17[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg20 = &buffer20;                                               // ARRAY
    arg21 = &dimsize20[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg22 = &buffer22;                                               // ARRAY
    arg23 = &dimsize22[0];                                           // SIZE1
    arg24 = &dimsize22[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "termpt", 14, 14, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "termpt" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("termpt", NPY_DOUBLE, swig_obj[8], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr9) && (PyArray_DIM(pyarr9, 0) != (3))) {
        handle_invalid_array_shape_1d("termpt", pyarr9, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "termpt" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_int(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "termpt" "', argument " "11"" of type '" "SpiceInt""'");
  } 
  arg11 = (SpiceInt)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "termpt" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "termpt" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_int(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "termpt" "', argument " "14"" of type '" "SpiceInt""'");
  } 
  arg14 = (SpiceInt)(val14);
  my_termpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceInt **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize15[0]
    };
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr15), buffer15, dims[0] * sizeof(SpiceInt));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr15);
    // AppendOutput steals the reference to the argument.
    pyarr15 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize17[0], dimsize17[1]
    };
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17,
      PyArray_SIZE(pyarr17) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr17);
    // AppendOutput steals the reference to the argument.
    pyarr17 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer20)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize20[0]
    };
    pyarr20 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr20)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr20), buffer20, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr20);
    // AppendOutput steals the reference to the argument.
    pyarr20 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer22)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize22[0], dimsize22[1]
    };
    pyarr22 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr22)) {
        handle_malloc_failure("termpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr22), buffer22,
      PyArray_SIZE(pyarr22) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr22);
    // AppendOutput steals the reference to the argument.
    pyarr22 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  {
    Py_XDECREF(pyarr22);
    PyMem_Free((void *) buffer22);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  {
    Py_XDECREF(pyarr22);
    PyMem_Free((void *) buffer22);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_timdef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "timdef", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, char INOUT_STRING[ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&buffer3, &dim13, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    resize_char_array_to_minimum_size(&buffer3, &dim13, NAMELEN, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  timdef_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("timdef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_timout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, TIMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("timout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "timout", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "timout" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("timout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("timout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  timout_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("timout");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tipbod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[3] ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("tipbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "tipbod", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tipbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tipbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tipbod" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tipbod" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  tipbod_c(arg1,arg2,arg3,(SpiceDouble (*)[3])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tipbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tipbod_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "tipbod_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tipbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tipbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tipbod_vector" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("tipbod_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  tipbod_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tipbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("tipbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("tipbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tisbod(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble (*arg4)[6] ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("tisbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg4 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr4);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr4, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "tisbod", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tisbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tisbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tisbod" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tisbod" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  tisbod_c(arg1,arg2,arg3,(SpiceDouble (*)[6])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tisbod");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tisbod_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "tisbod_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tisbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tisbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "tisbod_vector" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("tisbod_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  tisbod_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tisbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("tisbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("tisbod_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tkvrsn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  SpiceChar *result = 0 ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tkvrsn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tkvrsn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = (SpiceChar *)tkvrsn_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tkvrsn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj,
      PyString_FromString((char *) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  int alloc1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, MESSAGELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("tparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_tparse_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tpictr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceBoolean temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, TIMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("tpictr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  arg4 = &temp4;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim15 = max(1, MESSAGELEN);
    buffer5 = (SpiceChar *) PyMem_Malloc((dim15 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("tpictr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc5 = SWIG_NEWOBJ;
    
    buffer5[0] = '\0';   // String begins empty
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt)dim15;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tpictr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tpictr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_tpictr_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tpictr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceBoolean, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trace(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("trace", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("trace", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  result = trace_c((ConstSpiceDouble (*)[3])arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trace");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trace_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("trace_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  trace_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trace_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("trace_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize5[0], 1);
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("trace_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dim * sizeof(SpiceDouble));
    if (dimsize5[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr5, PyArray_DATA(pyarr5));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("trace_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr5 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
      // AppendOutput steals the reference to the argument.
      pyarr5 = NULL;
    }
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_trcoff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "trcoff", 0, 0, 0)) SWIG_fail;
  trcoff_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trcoff");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trcdep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt temp1 ;
  int res1 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  if (!SWIG_Python_UnpackTuple(args, "trcdep", 0, 0, 0)) SWIG_fail;
  trcdep_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trcdep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trcnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("trcnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "trcnam" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  trcnam_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trcnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tsetyr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tsetyr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  tsetyr_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tsetyr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twopi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "twopi", 0, 0, 0)) SWIG_fail;
  result = twopi_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("twopi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_twovec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceInt arg4 ;
  SpiceDouble (*arg5)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("twovec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "twovec", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("twovec", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("twovec", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twovec" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("twovec", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("twovec", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "twovec" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  twovec_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[3])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("twovec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_twovec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceInt arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceInt arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "twovec_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("twovec_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "twovec_vector" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("twovec_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  ecode8 = SWIG_AsVal_int(swig_obj[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "twovec_vector" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  twovec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("twovec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("twovec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("twovec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tyear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "tyear", 0, 0, 0)) SWIG_fail;
  result = tyear_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tyear");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ucrss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("ucrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ucrss", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ucrss", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("ucrss", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ucrss", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("ucrss", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ucrss_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ucrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ucrss_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "ucrss_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ucrss_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ucrss_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  ucrss_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ucrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("ucrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("ucrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unitim(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "unitim", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "unitim" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("unitim");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("unitim");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("unitim");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("unitim");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = unitim_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unitim");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unitim_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "unitim_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("unitim_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  unitim_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize5[0], 1);
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("unitim_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dim * sizeof(SpiceDouble));
    if (dimsize5[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr5, PyArray_DATA(pyarr5));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("unitim_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr5 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
      // AppendOutput steals the reference to the argument.
      pyarr5 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unload(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("unload");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("unload");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  unload_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unload");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_unorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("unorm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg3 = &temp3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("unorm", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("unorm", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  unorm_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unorm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unorm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("unorm_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  unorm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("unorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("unorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("unorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("unorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("unorm_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unormg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble **arg3 = (SpiceDouble **) 0 ;
  int *arg4 = (int *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble *buffer3 = NULL ;
  int dimsize3[1] ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg3 = &buffer3;                                               // ARRAY
    arg4 = &dimsize3[0];                                           // SIZE1
  }
  arg5 = &temp5;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("unormg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  my_unormg_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unormg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("unormg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize3[0]
    };
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("unormg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr3), buffer3, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_unormg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int *arg4 = (int *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "my_unormg_nomalloc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_unormg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "my_unormg_nomalloc" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_unormg_nomalloc" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  my_unormg_nomalloc(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_unormg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("unormg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  unormg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("unormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("unormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("unormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("unormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("unormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("unormg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_utc2et(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("utc2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("utc2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  utc2et_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("utc2et");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_vadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vadd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vadd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vadd", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vadd", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vadd", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vadd", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vadd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vadd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vadd_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vadd_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vadd_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vadd_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vadd_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vadd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vadd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vadd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vaddg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vaddg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vaddg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vaddg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  my_vaddg_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vaddg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("vaddg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize5[0]
    };
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("vaddg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vaddg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vaddg_nomalloc", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vaddg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("my_vaddg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  res5 = SWIG_ConvertPtr(swig_obj[2], &argp5,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "my_vaddg_nomalloc" "', argument " "5"" of type '" "SpiceDouble *""'"); 
  }
  arg5 = (SpiceDouble *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_vaddg_nomalloc" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  my_vaddg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vaddg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vaddg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vaddg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vaddg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vaddg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vaddg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vaddg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vaddg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vcrss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vcrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vcrss", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vcrss", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vcrss", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vcrss", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vcrss", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vcrss_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vcrss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vcrss_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vcrss_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vcrss_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vcrss_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vcrss_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vcrss_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vdist", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdist", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vdist", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vdist", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vdist", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = vdist_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdist_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vdist_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdist_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vdist_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vdist_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdist_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vdist_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vdist_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vdist_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdistg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vdistg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdistg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vdistg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  result = my_vdistg_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdistg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdistg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vdistg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdistg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vdistg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vdistg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdistg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vdistg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vdistg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vdistg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vdot", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdot", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vdot", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vdot", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vdot", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = vdot_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdot_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vdot_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdot_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vdot_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vdot_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vdot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vdot_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdotg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vdotg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdotg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vdotg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  result = my_vdotg_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdotg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vdotg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vdotg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vdotg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vdotg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vdotg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vdotg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vdotg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vdotg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vdotg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vequ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("vequ");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vequ", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vequ", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  vequ_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vequ");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vequ_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vequ_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vequ_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vequ_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vequg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble **arg3 = (SpiceDouble **) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble *buffer3 = NULL ;
  int dimsize3[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg3 = &buffer3;                                               // ARRAY
    arg4 = &dimsize3[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vequg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  my_vequg_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("vequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize3[0]
    };
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vequg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr3), buffer3, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vequg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vequg_nomalloc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vequg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "my_vequg_nomalloc" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_vequg_nomalloc" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  my_vequg_nomalloc(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vequg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vequg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vequg_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vequg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vhat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("vhat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vhat", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vhat", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  vhat_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vhat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vhat_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vhat_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vhat_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vhat_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vhatg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble **arg3 = (SpiceDouble **) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble *buffer3 = NULL ;
  int dimsize3[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg3 = &buffer3;                                               // ARRAY
    arg4 = &dimsize3[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vhatg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  my_vhatg_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vhatg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("vhatg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize3[0]
    };
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vhatg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr3), buffer3, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vhatg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vhatg_nomalloc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vhatg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "my_vhatg_nomalloc" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_vhatg_nomalloc" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  my_vhatg_nomalloc(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vhatg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vhatg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vhatg_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vhatg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vhatg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vhatg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcom3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble arg5 ;
  ConstSpiceDouble *arg6 ;
  SpiceDouble *arg7 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vlcom3");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcom3", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlcom3" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vlcom3", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vlcom3", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlcom3" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vlcom3", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("vlcom3", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "vlcom3" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("vlcom3", NPY_DOUBLE, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr6) && (PyArray_DIM(pyarr6, 0) != (3))) {
        handle_invalid_array_shape_1d("vlcom3", pyarr6, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
  }
  vlcom3_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcom3");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcom3_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int arg12 ;
  ConstSpiceDouble *arg13 = (ConstSpiceDouble *) 0 ;
  int arg14 ;
  int arg15 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  int *arg18 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[2] ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
    arg18 = &dimsize16[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcom3_vector", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
    if (PyArray_NDIM(pyarr11) == 0) {
      arg12 = 0;                                                 // DIM1
    } else {
      arg12 = (int) PyArray_DIM(pyarr11, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr13 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr13){
        handle_bad_array_conversion("vlcom3_vector", NPY_DOUBLE, swig_obj[5], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr13) == 1) {
      arg13 = (ConstSpiceDouble *) PyArray_DATA(pyarr13);                    // ARRAY
      arg14 = 0;                                                 // DIM1
      arg15 = (int) PyArray_DIM(pyarr13, 0);                        // DIM2
    } else {
      arg13 = (ConstSpiceDouble *) PyArray_DATA(pyarr13);                    // ARRAY
      arg14 = (int) PyArray_DIM(pyarr13, 0);                        // DIM1
      arg15 = (int) PyArray_DIM(pyarr13, 1);                        // DIM2
    }
  }
  vlcom3_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcom3_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("vlcom3_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize16[0], dimsize16[1]
    };
    if (dimsize16[0] == 0) {
      pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr16 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("vlcom3_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16,
      PyArray_SIZE(pyarr16) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr16);
    // AppendOutput steals the reference to the argument.
    pyarr16 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("vlcom");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcom", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlcom" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vlcom", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vlcom", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vlcom" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vlcom", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("vlcom", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  vlcom_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcom");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcom_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcom_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vlcom_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vlcom_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("vlcom_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("vlcom_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  vlcom_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcom_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("vlcom_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("vlcom_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcomg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcomg", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vlcomg" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vlcomg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "vlcomg" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("vlcomg", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    arg6 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  my_vlcomg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcomg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vlcomg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize7[0]
    };
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vlcomg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vlcomg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  int *arg8 = (int *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vlcomg_nomalloc", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "my_vlcomg_nomalloc" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("my_vlcomg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "my_vlcomg_nomalloc" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("my_vlcomg_nomalloc", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    arg6 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
  }
  res7 = SWIG_ConvertPtr(swig_obj[4], &argp7,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "my_vlcomg_nomalloc" "', argument " "7"" of type '" "SpiceDouble *""'"); 
  }
  arg7 = (SpiceDouble *)(argp7);
  res8 = SWIG_ConvertPtr(swig_obj[5], &argp8,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "my_vlcomg_nomalloc" "', argument " "8"" of type '" "int *""'"); 
  }
  arg8 = (int *)(argp8);
  my_vlcomg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vlcomg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vlcomg_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vlcomg_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vlcomg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("vlcomg_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("vlcomg_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  vlcomg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vlcomg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("vlcomg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("vlcomg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vminug(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble **arg3 = (SpiceDouble **) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble *buffer3 = NULL ;
  int dimsize3[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg3 = &buffer3;                                               // ARRAY
    arg4 = &dimsize3[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vminug", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  my_vminug_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vminug");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("vminug");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize3[0]
    };
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vminug");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr3), buffer3, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr3);
    PyMem_Free((void *) buffer3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vminug_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  int *arg4 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vminug_nomalloc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vminug_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "my_vminug_nomalloc" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_vminug_nomalloc" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  my_vminug_nomalloc(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vminug_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vminug_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vminug_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vminug_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vminug_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vminug_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vminus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("vminus");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vminus", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vminus", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  vminus_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vminus");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vminus_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vminus_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vminus_vector(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vminus_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vminus_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    if (dimsize4[0] == 0) {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vminus_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vnorm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vnorm", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vnorm", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = vnorm_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vnorm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vnorm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vnorm_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vnorm_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vnorm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vnorm_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vnormg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vnormg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = vnormg_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vnormg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vnormg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vnormg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vnormg_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vnormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vnormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vnormg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vnormg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vpack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vpack");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vpack", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vpack" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "vpack" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vpack" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  vpack_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vpack");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vpack_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vpack_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vpack_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vpack_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("vpack_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  vpack_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vpack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vpack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vpack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vperp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vperp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vperp", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vperp", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vperp", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vperp", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vperp", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vperp_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vperp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vperp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vperp_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vperp_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vperp_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vperp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vperp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vperp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vperp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprjp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vprjp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vprjp", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprjp", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vprjp", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vprjp", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("vprjp", pyarr2, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vprjp_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprjp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprjp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vprjp_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprjp_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vprjp_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vprjp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprjp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vprjp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vprjp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprjpi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vprjpi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!SWIG_Python_UnpackTuple(args, "vprjpi", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprjpi", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vprjpi", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vprjpi", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("vprjpi", pyarr2, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vprjpi", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (NPLANE))) {
        handle_invalid_array_shape_1d("vprjpi", pyarr3, NPLANE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  vprjpi_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprjpi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprjpi_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceBoolean **arg13 = (SpiceBoolean **) 0 ;
  int *arg14 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceBoolean *buffer13 = NULL ;
  int dimsize13[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vprjpi_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprjpi_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vprjpi_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("vprjpi_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  vprjpi_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprjpi_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("vprjpi_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("vprjpi_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("vprjpi_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize13[0], 1);
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("vprjpi_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13, dim * sizeof(SpiceBoolean));
    if (dimsize13[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr13, PyArray_DATA(pyarr13));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vprjpi_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr13 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
      // AppendOutput steals the reference to the argument.
      pyarr13 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vproj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vproj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vproj", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vproj", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vproj", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vproj", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vproj", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vproj_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vproj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vproj_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vproj_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vproj_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vproj_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vproj_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vproj_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vproj_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vproj_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vrel", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrel", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vrel", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vrel", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vrel", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = vrel_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vrel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrel_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vrel_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrel_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vrel_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vrel_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vrel_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vrel_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vrel_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vrel_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrelg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vrelg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrelg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vrelg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  result = my_vrelg_c(arg1,arg2,arg3,arg4);
  resultobj = SWIG_From_double((double)(result));
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrelg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vrelg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrelg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vrelg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vrelg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vrelg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vrelg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vrelg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vrelg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrotv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vrotv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vrotv", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrotv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vrotv", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vrotv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vrotv", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "vrotv" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  vrotv_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vrotv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vrotv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vrotv_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vrotv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vrotv_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("vrotv_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  vrotv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vrotv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("vrotv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("vrotv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vscl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vscl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vscl", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vscl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vscl", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vscl", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vscl_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vscl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vscl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vscl_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vscl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vscl_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  vscl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vscl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("vscl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("vscl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsclg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vsclg", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "vsclg" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vsclg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  my_vsclg_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsclg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vsclg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize4[0]
    };
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vsclg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vsclg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  int *arg5 = (int *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vsclg_nomalloc", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "my_vsclg_nomalloc" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("my_vsclg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_vsclg_nomalloc" "', argument " "4"" of type '" "SpiceDouble *""'"); 
  }
  arg4 = (SpiceDouble *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[3], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "my_vsclg_nomalloc" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  my_vsclg_nomalloc(arg1,arg2,arg3,arg4,arg5);
  resultobj = SWIG_Py_Void();
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsclg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
    arg8 = &dimsize6[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vsclg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsclg_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vsclg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  vsclg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsclg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("vsclg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize6[0], dimsize6[1]
    };
    if (dimsize6[0] == 0) {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("vsclg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6,
      PyArray_SIZE(pyarr6) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vsep", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsep", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vsep", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vsep", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vsep", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = vsep_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsep_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vsep_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsep_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vsep_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vsep_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vsep_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsepg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vsepg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsepg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vsepg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  result = my_vsepg_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsepg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsepg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vsepg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsepg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vsepg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vsepg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsepg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vsepg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vsepg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vsepg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("vsub");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vsub", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsub", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vsub", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vsub", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("vsub", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  vsub_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsub");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsub_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vsub_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsub_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vsub_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vsub_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsub_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vsub_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vsub_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsubg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vsubg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsubg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vsubg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  my_vsubg_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsubg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("vsubg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize5[0]
    };
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("vsubg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vsubg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_vsubg_nomalloc", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vsubg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("my_vsubg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  res5 = SWIG_ConvertPtr(swig_obj[2], &argp5,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "my_vsubg_nomalloc" "', argument " "5"" of type '" "SpiceDouble *""'"); 
  }
  arg5 = (SpiceDouble *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_vsubg_nomalloc" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  my_vsubg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vsubg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vsubg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vsubg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vsubg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vsubg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vsubg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vsubg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vsubg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vtmv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble (*arg2)[3] ;
  ConstSpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vtmv", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vtmv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vtmv", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("vtmv", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3) || PyArray_DIM(pyarr2, 1) != (3))) {
        handle_invalid_array_shape_2d("vtmv", pyarr2, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                            // DIM2
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vtmv", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("vtmv", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  result = vtmv_c(arg1,(ConstSpiceDouble (*)[3])arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vtmv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vtmv_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vtmv_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vtmv_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vtmv_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 2) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 1);                        // DIM3
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("vtmv_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  vtmv_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vtmv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("vtmv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("vtmv_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vtmv_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vtmvg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble *arg1 = (SpiceDouble *) 0 ;
  int arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  int arg7 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "vtmvg", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (SpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vtmvg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (SpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (SpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vtmvg", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    arg5 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
  }
  {
    //      (SpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("vtmvg", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    arg7 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
  }
  result = my_vtmvg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vtmvg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vtmvg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vtmvg_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vtmvg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vtmvg_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 2) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 1);                        // DIM3
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("vtmvg_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  vtmvg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vtmvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("vtmvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("vtmvg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vtmvg_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vupack(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vupack", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vupack", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  vupack_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vupack");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vupack_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  int *arg7 = (int *) 0 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vupack_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vupack_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceDouble));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vupack_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceDouble));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vupack_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("vupack_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vupack_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vzero(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceBoolean result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vzero", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("vzero", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = vzero_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vzero");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vzero_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceBoolean **arg4 = (SpiceBoolean **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceBoolean *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vzero_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vzero_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vzero_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vzero_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vzero_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceBoolean));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vzero_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vzerog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceBoolean result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vzerog", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = vzerog_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vzerog");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vzerog_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceBoolean **arg4 = (SpiceBoolean **) 0 ;
  int *arg5 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceBoolean *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vzerog_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  vzerog_vector(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vzerog_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("vzerog_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize4[0], 1);
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("vzerog_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dim * sizeof(SpiceBoolean));
    if (dimsize4[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr4, PyArray_DATA(pyarr4));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("vzerog_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr4 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
      // AppendOutput steals the reference to the argument.
      pyarr4 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xf2eul(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[6] ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xf2eul");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "xf2eul", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xf2eul", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6) || PyArray_DIM(pyarr1, 1) != (6))) {
        handle_invalid_array_shape_2d("xf2eul", pyarr1, 6, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[6]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "xf2eul" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "xf2eul" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "xf2eul" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  xf2eul_c((ConstSpiceDouble (*)[6])arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xf2eul");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xf2eul_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  int arg10 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  int *arg13 = (int *) 0 ;
  SpiceBoolean **arg14 = (SpiceBoolean **) 0 ;
  int *arg15 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[2] ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceBoolean *buffer14 = NULL ;
  int dimsize14[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
    arg13 = &dimsize11[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "xf2eul_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xf2eul_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("xf2eul_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("xf2eul_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("xf2eul_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    if (PyArray_NDIM(pyarr9) == 0) {
      arg10 = 0;                                                 // DIM1
    } else {
      arg10 = (int) PyArray_DIM(pyarr9, 0);                        // DIM1
    }
  }
  xf2eul_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xf2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("xf2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    if (dimsize11[0] == 0) {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("xf2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11,
      PyArray_SIZE(pyarr11) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("xf2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize14[0], 1);
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("xf2eul_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14, dim * sizeof(SpiceBoolean));
    if (dimsize14[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr14, PyArray_DATA(pyarr14));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("xf2eul_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr14 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr14);
      // AppendOutput steals the reference to the argument.
      pyarr14 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xf2rav(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[6] ;
  SpiceDouble (*arg2)[3] ;
  SpiceDouble *arg3 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("xf2rav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("xf2rav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xf2rav", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6) || PyArray_DIM(pyarr1, 1) != (6))) {
        handle_invalid_array_shape_2d("xf2rav", pyarr1, 6, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[6]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  xf2rav_c((ConstSpiceDouble (*)[6])arg1,(SpiceDouble (*)[3])arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xf2rav");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xf2rav_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xf2rav_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  xf2rav_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xf2rav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("xf2rav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xf2rav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("xf2rav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("xf2rav_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xfmsta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "xfmsta", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xfmsta", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("xfmsta", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  xfmsta_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xfmsta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xfmsta_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "xfmsta_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xfmsta_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  xfmsta_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("xfmsta_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xpose6(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[6] ;
  SpiceDouble (*arg2)[6] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("xpose6");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xpose6", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6) || PyArray_DIM(pyarr1, 1) != (6))) {
        handle_invalid_array_shape_2d("xpose6", pyarr1, 6, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[6]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  xpose6_c((ConstSpiceDouble (*)[6])arg1,(SpiceDouble (*)[6])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xpose6");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xpose6_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xpose6_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  xpose6_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xpose6_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("xpose6_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xpose6_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xpose(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[3] ;
  SpiceDouble (*arg2)[3] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("xpose");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xpose", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3) || PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_2d("xpose", pyarr1, 3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  xpose_c((ConstSpiceDouble (*)[3])arg1,(SpiceDouble (*)[3])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xpose");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xpose_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xpose_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  xpose_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xpose_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("xpose_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xpose_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xposeg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
    arg6 = &dimsize4[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xposeg", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  my_xposeg_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xposeg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    //      (int *SIZE1, int *SIZE2, SpiceDouble **OUT_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("xposeg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("xposeg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4,
      PyArray_SIZE(pyarr4) * sizeof(SpiceDouble));
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_xposeg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  int *arg5 = (int *) 0 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "my_xposeg_nomalloc", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_xposeg_nomalloc", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
    arg3 = (int) PyArray_DIM(pyarr1, 1);                           // DIM2
  }
  res4 = SWIG_ConvertPtr(swig_obj[1], &argp4,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "my_xposeg_nomalloc" "', argument " "4"" of type '" "SpiceDouble *""'"); 
  }
  arg4 = (SpiceDouble *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[2], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "my_xposeg_nomalloc" "', argument " "5"" of type '" "int *""'"); 
  }
  arg5 = (int *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_xposeg_nomalloc" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  my_xposeg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_xposeg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("xposeg_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  xposeg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("xposeg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("xposeg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("xposeg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_azlcpo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg5 ;
  SpiceBoolean arg6 ;
  ConstSpiceDouble *arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  if (!SWIG_Python_UnpackTuple(args, "azlcpo", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "azlcpo" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "azlcpo" "', argument " "5"" of type '" "SpiceBoolean""'");
  } 
  arg5 = (SpiceBoolean)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "azlcpo" "', argument " "6"" of type '" "SpiceBoolean""'");
  } 
  arg6 = (SpiceBoolean)(val6);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("azlcpo", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 0) != (3))) {
        handle_invalid_array_shape_1d("azlcpo", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  azlcpo_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("azlcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_azlcpo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg6 ;
  SpiceBoolean arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  int arg10 ;
  ConstSpiceChar *arg11 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg12 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  int alloc11 = 0 ;
  int alloc12 = 0 ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "azlcpo_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("azlcpo_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "azlcpo_vector" "', argument " "6"" of type '" "SpiceBoolean""'");
  } 
  arg6 = (SpiceBoolean)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "azlcpo_vector" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("azlcpo_vector", NPY_DOUBLE, swig_obj[6], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr8) == 1) {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = 0;                                                 // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 0);                        // DIM2
    } else {
      arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                    // ARRAY
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
      arg10 = (int) PyArray_DIM(pyarr8, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg11, NULL, &alloc11);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg12, NULL, &alloc12);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  azlcpo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("azlcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("azlcpo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_azlrec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceBoolean arg4 ;
  SpiceBoolean arg5 ;
  SpiceDouble *arg6 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("azlrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "azlrec", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "azlrec" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "azlrec" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "azlrec" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "azlrec" "', argument " "4"" of type '" "SpiceBoolean""'");
  } 
  arg4 = (SpiceBoolean)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "azlrec" "', argument " "5"" of type '" "SpiceBoolean""'");
  } 
  arg5 = (SpiceBoolean)(val5);
  azlrec_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("azlrec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_azlrec_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceBoolean arg7 ;
  SpiceBoolean arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "azlrec_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("azlrec_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("azlrec_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("azlrec_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "azlrec_vector" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[4], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "azlrec_vector" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  azlrec_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("azlrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("azlrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("azlrec_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_badkpv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceChar arg6 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "badkpv", 6, 6, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "badkpv" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "badkpv" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[5], &arg6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("badkpv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  badkpv_c(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  {
    
  }
  {
    
  }
  return resultobj;
fail:
  {
    
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_brcktd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "brcktd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "brcktd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "brcktd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "brcktd" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  result = brcktd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("brcktd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_brcktd_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "brcktd_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("brcktd_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("brcktd_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("brcktd_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  brcktd_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("brcktd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("brcktd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize7[0], 1);
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("brcktd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7, dim * sizeof(SpiceDouble));
    if (dimsize7[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr7, PyArray_DATA(pyarr7));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("brcktd_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr7 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr7);
      // AppendOutput steals the reference to the argument.
      pyarr7 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_brckti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "brckti", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "brckti" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "brckti" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "brckti" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = brckti_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("brckti");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bschoc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceInt *arg5 = (ConstSpiceInt *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "bschoc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("bschoc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bschoc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("bschoc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("bschoc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("bschoc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("bschoc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("bschoc", NPY_INT, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceInt *) PyArray_DATA(pyarr5);                          // ARRAY
  }
  result = bschoc_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bschoc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bschoi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  ConstSpiceInt *arg4 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "bschoi", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bschoi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, SpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("bschoi", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("bschoi", NPY_INT, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceInt *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  result = bschoi_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bschoi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  
  {
    //      (SpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bsrchc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "bsrchc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("bsrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("bsrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("bsrchc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("bsrchc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("bsrchc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("bsrchc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  result = bsrchc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bsrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bsrchd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "bsrchd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bsrchd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("bsrchd", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = bsrchd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bsrchd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_bsrchd_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "my_bsrchd_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "my_bsrchd_vector" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "my_bsrchd_vector" "', argument " "2"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg2 = (ConstSpiceDouble *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "my_bsrchd_vector" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = my_bsrchd_vector(arg1,arg2,arg3);
  resultobj = SWIG_From_int((int)(result));
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_bsrchd_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  SpiceInt **arg6 = (SpiceInt **) 0 ;
  int *arg7 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceInt *buffer6 = NULL ;
  int dimsize6[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "bsrchd_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("bsrchd_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("bsrchd_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  bsrchd_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bsrchd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("bsrchd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize6[0], 1);
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("bsrchd_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dim * sizeof(SpiceInt));
    if (dimsize6[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr6, PyArray_DATA(pyarr6));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("bsrchd_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr6 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr6);
      // AppendOutput steals the reference to the argument.
      pyarr6 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_bsrchi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "bsrchi", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "bsrchi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("bsrchi", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = bsrchi_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("bsrchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 ;
  SpiceDouble arg4 ;
  SpiceInt arg5 ;
  SpiceDouble **arg6 = (SpiceDouble **) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble *buffer6 = NULL ;
  int dimsize6[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg6 = &buffer6;                                               // ARRAY
    arg7 = &dimsize6[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "chbder", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbder", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (SpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("chbder", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (2))) {
        handle_invalid_array_shape_1d("chbder", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "chbder" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "chbder" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  my_chbder_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbder");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer6)) {
        handle_malloc_failure("chbder");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize6[0]
    };
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("chbder");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr6), buffer6, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr6);
    PyMem_Free((void *) buffer6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbder_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceDouble *arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceInt arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
    arg10 = &dimsize8[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "chbder_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbder_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (SpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("chbder_vector", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (2))) {
        handle_invalid_array_shape_1d("chbder_vector", pyarr4, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("chbder_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "chbder_vector" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  chbder_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  resultobj = SWIG_Py_Void();
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("chbder_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize8[0], dimsize8[1]
    };
    if (dimsize8[0] == 0) {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr8 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("chbder_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8,
      PyArray_SIZE(pyarr8) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbigr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "chbigr", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbigr", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("chbigr", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (2))) {
        handle_invalid_array_shape_1d("chbigr", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "chbigr" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  my_chbigr_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbigr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbigr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "chbigr_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbigr_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("chbigr_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("chbigr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  chbigr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbigr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("chbigr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("chbigr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("chbigr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("chbigr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("chbigr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("chbigr_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "chbint", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbint", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("chbint", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (2))) {
        handle_invalid_array_shape_1d("chbint", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "chbint" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  my_chbint_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbint_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "chbint_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbint_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("chbint_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("chbint_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  chbint_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("chbint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("chbint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("chbint_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("chbint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("chbint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("chbint_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val4 ;
  int ecode4 = 0 ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "chbval", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbval", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("chbval", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (2))) {
        handle_invalid_array_shape_1d("chbval", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "chbval" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  my_chbval_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbval");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_chbval_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "chbval_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("chbval_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("chbval_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("chbval_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  chbval_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("chbval_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("chbval_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("chbval_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("chbval_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ckcls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckfrot(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble (*arg3)[3] ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("ckfrot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  arg4 = &temp4;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!SWIG_Python_UnpackTuple(args, "ckfrot", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckfrot" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckfrot" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ckfrot_c(arg1,arg2,(SpiceDouble (*)[3])arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckfrot");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckfrot_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  SpiceInt **arg8 = (SpiceInt **) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceBoolean **arg10 = (SpiceBoolean **) 0 ;
  int *arg11 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceInt *buffer8 = NULL ;
  int dimsize8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceBoolean *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckfrot_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckfrot_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckfrot_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ckfrot_vector", NPY_DOUBLE, swig_obj[2], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 2) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 1);                        // DIM3
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 2);                        // DIM3
    }
  }
  ckfrot_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckfrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("ckfrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("ckfrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceInt));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckfrot_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("ckfrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("ckfrot_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceBoolean));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckfrot_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckfxfm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble (*arg3)[6] ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceBoolean mybool5 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("ckfxfm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg3 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr3);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  arg4 = &temp4;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  if (!SWIG_Python_UnpackTuple(args, "ckfxfm", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckfxfm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckfxfm" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ckfxfm_c(arg1,arg2,(SpiceDouble (*)[6])arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckfxfm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckfxfm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  SpiceInt **arg8 = (SpiceInt **) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceBoolean **arg10 = (SpiceBoolean **) 0 ;
  int *arg11 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceInt *buffer8 = NULL ;
  int dimsize8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceBoolean *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckfxfm_vector", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckfxfm_vector" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckfxfm_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ckfxfm_vector", NPY_DOUBLE, swig_obj[2], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 2) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 1);                        // DIM3
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 2);                        // DIM3
    }
  }
  ckfxfm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckfxfm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("ckfxfm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("ckfxfm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceInt));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckfxfm_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("ckfxfm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("ckfxfm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceBoolean));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("ckfxfm_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgr02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      10
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("ckgr02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgr02", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgr02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckgr02", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("ckgr02", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckgr02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ckgr02_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgr02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckgr03(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceInt arg3 ;
  SpiceDouble **arg4 = (SpiceDouble **) 0 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceDouble *buffer4 = NULL ;
  int dimsize4[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg4 = &buffer4;                                               // ARRAY
    arg5 = &dimsize4[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ckgr03", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckgr03" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("ckgr03", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("ckgr03", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckgr03" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  my_ckgr03_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckgr03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("ckgr03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize4[0]
    };
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("ckgr03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr4), buffer4, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
    PyMem_Free((void *) buffer4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cklpf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("cklpf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cklpf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  cklpf_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cklpf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckmeta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "ckmeta", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckmeta" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ckmeta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckmeta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ckmeta_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckmeta");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cknr02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "cknr02", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cknr02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("cknr02", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("cknr02", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  cknr02_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cknr02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cknr03(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "cknr03", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cknr03" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("cknr03", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("cknr03", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  cknr03_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cknr03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "ckopn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckopn" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ckopn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckupf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckupf" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ckupf_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckupf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckw01(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble (*arg10)[4] ;
  ConstSpiceDouble (*arg11)[3] ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyObject *swig_obj[10] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ckw01", 10, 10, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckw01" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckw01" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckw01" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckw01" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("ckw01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ckw01" "', argument " "6"" of type '" "SpiceBoolean""'");
  } 
  arg6 = (SpiceBoolean)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("ckw01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("ckw01", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    arg8 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  res10 = SWIG_ConvertPtr(swig_obj[8], &argp10,SWIGTYPE_p_a_4__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ckw01" "', argument " "10"" of type '" "ConstSpiceDouble [][4]""'"); 
  } 
  arg10 = (ConstSpiceDouble (*)[4])(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[9], &argp11,SWIGTYPE_p_a_3__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ckw01" "', argument " "11"" of type '" "ConstSpiceDouble [][3]""'"); 
  } 
  arg11 = (ConstSpiceDouble (*)[3])(argp11);
  ckw01_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(ConstSpiceDouble (*)[4])arg10,(ConstSpiceDouble (*)[3])arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckw01");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckw02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceInt arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble (*arg10)[4] ;
  ConstSpiceDouble (*arg11)[3] ;
  ConstSpiceDouble *arg12 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  PyArrayObject *pyarr12 = NULL ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ckw02", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckw02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckw02" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckw02" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckw02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("ckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("ckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ckw02", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    arg7 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("ckw02", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
  }
  res10 = SWIG_ConvertPtr(swig_obj[8], &argp10,SWIGTYPE_p_a_4__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ckw02" "', argument " "10"" of type '" "ConstSpiceDouble [][4]""'"); 
  } 
  arg10 = (ConstSpiceDouble (*)[4])(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[9], &argp11,SWIGTYPE_p_a_3__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ckw02" "', argument " "11"" of type '" "ConstSpiceDouble [][3]""'"); 
  } 
  arg11 = (ConstSpiceDouble (*)[3])(argp11);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr12 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr12){
        handle_bad_array_conversion("ckw02", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg12 = (ConstSpiceDouble *) PyArray_DATA(pyarr12);                          // ARRAY
  }
  ckw02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(ConstSpiceDouble (*)[4])arg10,(ConstSpiceDouble (*)[3])arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckw03(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  ConstSpiceDouble *arg9 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble (*arg10)[4] ;
  ConstSpiceDouble (*arg11)[3] ;
  SpiceInt arg12 ;
  ConstSpiceDouble *arg13 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  PyArrayObject *pyarr13 = NULL ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ckw03", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckw03" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ckw03" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckw03" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckw03" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("ckw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ckw03" "', argument " "6"" of type '" "SpiceBoolean""'");
  } 
  arg6 = (SpiceBoolean)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("ckw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("ckw03", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    arg8 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  res10 = SWIG_ConvertPtr(swig_obj[8], &argp10,SWIGTYPE_p_a_4__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ckw03" "', argument " "10"" of type '" "ConstSpiceDouble [][4]""'"); 
  } 
  arg10 = (ConstSpiceDouble (*)[4])(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[9], &argp11,SWIGTYPE_p_a_3__ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ckw03" "', argument " "11"" of type '" "ConstSpiceDouble [][3]""'"); 
  } 
  arg11 = (ConstSpiceDouble (*)[3])(argp11);
  ecode12 = SWIG_AsVal_int(swig_obj[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "ckw03" "', argument " "12"" of type '" "SpiceInt""'");
  } 
  arg12 = (SpiceInt)(val12);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr13 = PyArray_FROMANY(swig_obj[11], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr13){
        handle_bad_array_conversion("ckw03", NPY_DOUBLE, swig_obj[11], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg13 = (ConstSpiceDouble *) PyArray_DATA(pyarr13);                          // ARRAY
  }
  ckw03_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(ConstSpiceDouble (*)[4])arg10,(ConstSpiceDouble (*)[3])arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ckw05(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceInt arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg8 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceInt arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg12 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg13 ;
  SpiceInt arg14 ;
  ConstSpiceDouble *arg15 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int alloc9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  double val13 ;
  int ecode13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  PyArrayObject *pyarr15 = NULL ;
  PyObject *swig_obj[14] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ckw05", 14, 14, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ckw05" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ckw05" "', argument " "2"" of type '" "ConstSpiceChar *""'"); 
  }
  arg2 = (ConstSpiceChar *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ckw05" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ckw05" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ckw05" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ckw05" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("ckw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ckw05" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("ckw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ckw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("ckw05", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    arg10 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceDouble *IN_ARRAY2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr12 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr12){
        handle_bad_array_conversion("ckw05", NPY_DOUBLE, swig_obj[10], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg12 = (ConstSpiceDouble *) PyArray_DATA(pyarr12);                                // ARRAY
  }
  ecode13 = SWIG_AsVal_double(swig_obj[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "ckw05" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_int(swig_obj[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "ckw05" "', argument " "14"" of type '" "SpiceInt""'");
  } 
  arg14 = (SpiceInt)(val14);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr15 = PyArray_FROMANY(swig_obj[13], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr15){
        handle_bad_array_conversion("ckw05", NPY_DOUBLE, swig_obj[13], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg15 = (ConstSpiceDouble *) PyArray_DATA(pyarr15);                          // ARRAY
  }
  my_ckw05_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ckw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr12);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr15);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr12);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cmprss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceChar arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  char val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, LONGMSGLEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("cmprss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "cmprss", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_char(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "cmprss" "', argument " "1"" of type '" "SpiceChar""'");
  } 
  arg1 = (SpiceChar)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "cmprss" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("cmprss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cmprss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  cmprss_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cmprss");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_cpos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "cpos", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("cpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("cpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cpos" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = cpos_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cposr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "cposr", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("cposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("cposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "cposr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = cposr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_cvpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceBoolean *arg2 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceBoolean mybool2 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg2 = &mybool2;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("cvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("cvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  cvpool_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("cvpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg2 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dafac", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafac" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("dafac");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("dafac");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("dafac");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("dafac");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  dafac_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafac");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafbbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafbbs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafbbs_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafbbs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafcs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafcs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafcs_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafcs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafdc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafdc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafdc_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafdc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  char (*arg5)[COMMENTLEN] ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char *buffer2 ;
  int dimsize2[2] ;
  PyObject *list2 = NULL ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize2[0] = COMMENTS;                                       // ARRAY_dim0
    dimsize2[1] = COMMENTLEN;                                       // NARRAY_dim1
    if (dimsize2[1] < 2) {
      dimsize2[1] = 2;
    }
    
    buffer2 = (char *) PyMem_Malloc(dimsize2[0] * dimsize2[1] * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("dafec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = buffer2;                                                // ARRAY
    arg2 = dimsize2[0];                                            // DIM1
    arg3 = dimsize2[1];                                            // DIM2
    arg4 = &dimsize2[0];                                           // NSTRINGS
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafec_c(arg1,arg2,arg3,arg4,(char (*)[COMMENTLEN])arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list2 = PyList_New(dimsize2[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list2)) {
        handle_malloc_failure("dafec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize2[0]; i++) {
      char *str = &buffer2[i * dimsize2[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dafec");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list2, i, value);
    }
    list2 = Py_BuildValue("[N]", list2);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list2);
    list2 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer2);
    Py_XDECREF(list2);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer2);
    Py_XDECREF(list2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_daffpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean *arg1 = (SpiceBoolean *) 0 ;
  SpiceBoolean mybool1 ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg1 = &mybool1;
  }
  if (!SWIG_Python_UnpackTuple(args, "daffpa", 0, 0, 0)) SWIG_fail;
  daffpa_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("daffpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg1 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafgh(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt temp1 ;
  int res1 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  if (!SWIG_Python_UnpackTuple(args, "dafgh", 0, 0, 0)) SWIG_fail;
  dafgh_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafgh");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafgsr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 ;
  int *arg6 = (int *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int size5[1] ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("dafgsr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    arg6 = &size5[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "dafgsr", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafgsr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dafgsr" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dafgsr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dafgsr" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  my_dafgsr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafgsr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size5[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafhsf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafhsf" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dafhsf_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafhsf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafopw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dafopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dafopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dafopw_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  ConstSpiceInt *arg4 = (ConstSpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  int *arg6 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DAFSIZE
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("dafps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dafps", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dafps", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dafps", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceInt *) PyArray_DATA(pyarr3);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  res6 = SWIG_ConvertPtr(swig_obj[2], &argp6,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dafps" "', argument " "6"" of type '" "int *""'"); 
  }
  arg6 = (int *)(argp6);
  my_dafps_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafrfr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceInt temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, FILELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("dafrfr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dafrfr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_dafrfr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafrfr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dafrs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dafrs", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
  }
  dafrs_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dafrs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasac(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasac", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasac" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("dasac");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("dasac");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("dasac");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("dasac");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  dasac_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasac");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasadc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasadc", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasadc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasadc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasadc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dasadc" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dasadc" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dasadc" "', argument " "6"" of type '" "ConstSpiceChar *""'"); 
  }
  arg6 = (ConstSpiceChar *)(argp6);
  dasadc_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasadc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasadd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasadd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasadd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dasadd", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dasadd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasadd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasadi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasadi", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasadi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dasadi", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dasadi_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasadi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dascls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dascls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dascls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dascls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasdc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasdc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dasdc_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasdc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  char (*arg5)[COMMENTLEN] ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  char *buffer2 ;
  int dimsize2[2] ;
  PyObject *list2 = NULL ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize2[0] = COMMENTS;                                       // ARRAY_dim0
    dimsize2[1] = COMMENTLEN;                                       // NARRAY_dim1
    if (dimsize2[1] < 2) {
      dimsize2[1] = 2;
    }
    
    buffer2 = (char *) PyMem_Malloc(dimsize2[0] * dimsize2[1] * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("dasec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = buffer2;                                                // ARRAY
    arg2 = dimsize2[0];                                            // DIM1
    arg3 = dimsize2[1];                                            // DIM2
    arg4 = &dimsize2[0];                                           // NSTRINGS
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dasec_c(arg1,arg2,arg3,arg4,(char (*)[COMMENTLEN])arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list2 = PyList_New(dimsize2[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list2)) {
        handle_malloc_failure("dasec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize2[0]; i++) {
      char *str = &buffer2[i * dimsize2[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dasec");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list2, i, value);
    }
    list2 = Py_BuildValue("[N]", list2);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list2);
    list2 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer2);
    Py_XDECREF(list2);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer2);
    Py_XDECREF(list2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dashfn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, FILELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("dashfn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dashfn" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dashfn_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dashfn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dashfs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 ;
  SpiceInt *arg8 ;
  SpiceInt *arg9 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("dashfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceInt *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("dashfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceInt *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("dashfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceInt *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dashfs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dashfs_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dashfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_daslla(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "daslla" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  daslla_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("daslla");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasllc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasllc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dasllc_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasllc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasonw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "dasonw", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dasonw" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  dasonw_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasonw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasopr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dasopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dasopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dasopr_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt temp1 ;
  int res1 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  if (!SWIG_Python_UnpackTuple(args, "dasops", 0, 0, 0)) SWIG_fail;
  dasops_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasops");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasopw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dasopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dasopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  dasopw_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasrdc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  char *arg7 = (char *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int res7 ;
  char *buf7 = 0 ;
  int alloc7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasrdc", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasrdc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasrdc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasrdc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dasrdc" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dasrdc" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dasrdc" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  res7 = SWIG_AsCharPtrAndSize(swig_obj[6], &buf7, NULL, &alloc7);
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dasrdc" "', argument " "7"" of type '" "char *""'");
  }
  arg7 = (char *)(buf7);
  dasrdc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasrdc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
  return resultobj;
fail:
  if (alloc7 == SWIG_NEWOBJ) free((char*)buf7);
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasrdd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int size4[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXRECS
    };                               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dasrdd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    arg5 = &size4[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dasrdd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasrdd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasrdd" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasrdd" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  my_dasrdd_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasrdd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size4[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasrdi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 ;
  int *arg5 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  int size4[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXRECS
    };                               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dasrdi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceInt *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    arg5 = &size4[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dasrdi", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasrdi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasrdi" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasrdi" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  my_dasrdi_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasrdi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size4[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasrfr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceInt temp8 ;
  int res8 = SWIG_TMPOBJ ;
  SpiceInt temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, 10);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("dasrfr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, 61);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("dasrfr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  arg9 = &temp9;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasrfr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  my_dasrfr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasrfr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasudc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasudc", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasudc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasudc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasudc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dasudc" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dasudc" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dasudc" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dasudc" "', argument " "7"" of type '" "ConstSpiceChar *""'"); 
  }
  arg7 = (ConstSpiceChar *)(argp7);
  dasudc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasudc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasudd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasudd", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasudd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasudd" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasudd" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dasudd", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  dasudd_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasudd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dasudi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceInt *arg4 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dasudi", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dasudi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dasudi" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dasudi" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dasudi", NPY_INT, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceInt *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  dasudi_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dasudi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_daswbr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "daswbr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  daswbr_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("daswbr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dazldr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceBoolean arg4 ;
  SpiceBoolean arg5 ;
  SpiceDouble (*arg6)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("dazldr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr6);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr6, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "dazldr", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dazldr" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dazldr" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dazldr" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dazldr" "', argument " "4"" of type '" "SpiceBoolean""'");
  } 
  arg4 = (SpiceBoolean)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dazldr" "', argument " "5"" of type '" "SpiceBoolean""'");
  } 
  arg5 = (SpiceBoolean)(val5);
  dazldr_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dazldr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dazldr_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceBoolean arg7 ;
  SpiceBoolean arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "dazldr_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dazldr_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dazldr_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("dazldr_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dazldr_vector" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[4], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "dazldr_vector" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  dazldr_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dazldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("dazldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("dazldr_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlabbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceBoolean mybool3 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DLASIZE
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("dlabbs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlabbs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dlabbs_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlabbs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlabfs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceBoolean mybool3 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DLASIZE
    };                               // DIMENSIONS
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("dlabfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlabfs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dlabfs_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlabfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlabns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlabns" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dlabns_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlabns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlaens(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlaens" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dlaens_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlaens");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlafns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt *arg3 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DLASIZE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("dlafns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceInt *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!SWIG_Python_UnpackTuple(args, "dlafns", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlafns" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dlafns", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dlafns", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dlafns_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlafns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlafps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt *arg3 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DLASIZE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("dlafps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceInt *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!SWIG_Python_UnpackTuple(args, "dlafps", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dlafps" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dlafps", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dlafps", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dlafps_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlafps");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dlaopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "dlaopn", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dlaopn" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  dlaopn_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dlaopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnearp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 ;
  SpiceDouble *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("dnearp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      2
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("dnearp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "dnearp", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dnearp", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("dnearp", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dnearp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dnearp" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dnearp" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  dnearp_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dnearp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dnearp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceBoolean **arg16 = (SpiceBoolean **) 0 ;
  int *arg17 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceBoolean *buffer16 = NULL ;
  int dimsize16[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dnearp_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dnearp_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dnearp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("dnearp_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("dnearp_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  dnearp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceBoolean **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("dnearp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceBoolean));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("dnearp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dp2hx(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceChar *arg2 ;
  double val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dp2hx", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dp2hx" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "dp2hx" "', argument " "2"" of type '" "SpiceChar [256]""'"); 
  } 
  arg2 = (SpiceChar *)(argp2);
  my_dp2hx_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dp2hx");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdazl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceBoolean arg4 ;
  SpiceBoolean arg5 ;
  SpiceDouble (*arg6)[3] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("drdazl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr6);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr6, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "drdazl", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "drdazl" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "drdazl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "drdazl" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "drdazl" "', argument " "4"" of type '" "SpiceBoolean""'");
  } 
  arg4 = (SpiceBoolean)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "drdazl" "', argument " "5"" of type '" "SpiceBoolean""'");
  } 
  arg5 = (SpiceBoolean)(val5);
  drdazl_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdazl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_drdazl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceBoolean arg7 ;
  SpiceBoolean arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "drdazl_vector", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("drdazl_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("drdazl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("drdazl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  ecode7 = SWIG_AsVal_int(swig_obj[3], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "drdazl_vector" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[4], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "drdazl_vector" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  drdazl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("drdazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("drdazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("drdazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskb02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble (*arg6)[2] ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 ;
  SpiceInt *arg9 ;
  SpiceInt *arg10 = (SpiceInt *) 0 ;
  SpiceInt *arg11 = (SpiceInt *) 0 ;
  SpiceInt *arg12 = (SpiceInt *) 0 ;
  SpiceInt *arg13 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceInt temp10 ;
  int res10 = SWIG_TMPOBJ ;
  SpiceInt temp11 ;
  int res11 = SWIG_TMPOBJ ;
  SpiceInt temp12 ;
  int res12 = SWIG_TMPOBJ ;
  SpiceInt temp13 ;
  int res13 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 2
    };               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("dskb02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr6);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr6, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  arg7 = &temp7;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("dskb02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceDouble *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("dskb02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceInt *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  arg11 = &temp11;
  arg12 = &temp12;
  arg13 = &temp13;
  if (!SWIG_Python_UnpackTuple(args, "dskb02", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskb02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskb02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskb02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dskb02_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[2])arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskb02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg12)));
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res13)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg13)));
  } else {
    int new_flags = SWIG_IsNewObj(res13) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg13), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceBoolean arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskcls", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dskcls" "', argument " "2"" of type '" "SpiceBoolean""'");
  } 
  arg2 = (SpiceBoolean)(val2);
  dskcls_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskd02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceDouble *arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int size5[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int DIM1, int *SIZE1, SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      MAXVALS
    };                               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("dskd02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    arg5 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    arg6 = &size5[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dskd02", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskd02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskd02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskd02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskd02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dskd02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  dskd02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskd02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size5[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskgd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceDouble *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DSKSIZE
    };                               // DIMENSIONS
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("dskgd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dskgd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskgd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskgd", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskgd", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dskgd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskgd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskgtl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskgtl" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  dskgtl_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskgtl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dski02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  arg6 = &temp6;
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "dski02", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dski02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dski02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dski02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dski02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dski02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dski02" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  dski02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dski02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskmi2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceInt arg3 ;
  ConstSpiceInt (*arg4)[3] ;
  SpiceDouble arg5 ;
  SpiceInt arg6 ;
  SpiceBoolean arg7 ;
  SpiceDouble *arg8 ;
  SpiceInt *arg9 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  PyObject *swig_obj[5] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_DSK02_SPADSZ
    };                               // DIMENSIONS
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("dskmi2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceDouble *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_DSK02_SPAISZ
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("dskmi2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceInt *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dskmi2", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dskmi2", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskmi2", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dskmi2", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskmi2", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceInt (*)[3]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dskmi2" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dskmi2" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "dskmi2" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  my_dskmi2_c(arg1,(ConstSpiceDouble (*)[3])arg2,arg3,(ConstSpiceInt (*)[3])arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskmi2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskn02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("dskn02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dskn02", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskn02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskn02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskn02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskn02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  dskn02_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskn02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskobj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 ;
  int *arg3 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("dskobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg3 = &size2[0];                                              // SIZE1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dskobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_dskobj_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskobj");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "dskopn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dskopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("dskopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskopn" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  dskopn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskp02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceInt (*arg6)[3] ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskp02", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskp02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskp02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskp02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskp02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dskp02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dskp02" "', argument " "5"" of type '" "SpiceInt *""'"); 
  }
  arg5 = (SpiceInt *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_a_3__SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dskp02" "', argument " "6"" of type '" "SpiceInt [NPLATES][3]""'"); 
  } 
  arg6 = (SpiceInt (*)[3])(argp6);
  dskp02_c(arg1,arg2,arg3,arg4,arg5,(SpiceInt (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskp02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskrb2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble (*arg2)[3] ;
  SpiceInt arg3 ;
  ConstSpiceInt (*arg4)[3] ;
  SpiceInt arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg7 = &temp7;
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "dskrb2", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("dskrb2", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskrb2", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_INT, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dskrb2", NPY_INT, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskrb2", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceInt (*)[3]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dskrb2" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("dskrb2", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  dskrb2_c(arg1,(ConstSpiceDouble (*)[3])arg2,arg3,(ConstSpiceInt (*)[3])arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskrb2");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dsksrf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 ;
  int *arg4 = (int *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int size3[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      MAXIDS
    };                               // ARRAY
    pyarr3 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr3)) {
        handle_malloc_failure("dsksrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceInt *) PyArray_DATA(pyarr3);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
    arg4 = &size3[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "dsksrf", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("dsksrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dsksrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dsksrf" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  my_dsksrf_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dsksrf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size3[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr3, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr3);
    // AppendOutput steals the reference to the argument.
    pyarr3 = NULL;
  }
  {
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskstl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskstl", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskstl" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dskstl" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  dskstl_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskstl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskv02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble (*arg6)[3] ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskv02", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskv02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskv02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskv02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskv02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dskv02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "dskv02" "', argument " "5"" of type '" "SpiceInt *""'"); 
  }
  arg5 = (SpiceInt *)(argp5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_a_3__SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "dskv02" "', argument " "6"" of type '" "SpiceDouble [NPLATES][3]""'"); 
  } 
  arg6 = (SpiceDouble (*)[3])(argp6);
  dskv02_c(arg1,arg2,arg3,arg4,arg5,(SpiceDouble (*)[3])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskv02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskw02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceInt arg6 ;
  ConstSpiceDouble *arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble arg15 ;
  SpiceInt arg16 ;
  ConstSpiceDouble (*arg17)[3] ;
  SpiceInt arg18 ;
  ConstSpiceInt (*arg19)[3] ;
  ConstSpiceDouble *arg20 ;
  ConstSpiceInt *arg21 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyArrayObject *pyarr16 = NULL ;
  PyArrayObject *pyarr18 = NULL ;
  void *argp20 = 0 ;
  int res20 = 0 ;
  void *argp21 = 0 ;
  int res21 = 0 ;
  PyObject *swig_obj[19] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskw02", 19, 19, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskw02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "dskw02" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskw02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "dskw02" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("dskw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "dskw02" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "dskw02" "', argument " "7"" of type '" "ConstSpiceDouble []""'"); 
  } 
  arg7 = (ConstSpiceDouble *)(argp7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "dskw02" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "dskw02" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "dskw02" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "dskw02" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "dskw02" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "dskw02" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "dskw02" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "dskw02" "', argument " "15"" of type '" "SpiceDouble""'");
  } 
  arg15 = (SpiceDouble)(val15);
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr16 = PyArray_FROMANY(swig_obj[15], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr16){
        handle_bad_array_conversion("dskw02", NPY_DOUBLE, swig_obj[15], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr16) && (PyArray_DIM(pyarr16, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskw02", pyarr16, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg17 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr16);                                // ARRAY
    arg16 = (int) PyArray_DIM(pyarr16, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceInt IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr18 = PyArray_FROMANY(swig_obj[16], NPY_INT, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr18){
        handle_bad_array_conversion("dskw02", NPY_INT, swig_obj[16], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr18) && (PyArray_DIM(pyarr18, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskw02", pyarr18, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg19 = (ConstSpiceInt (*)[3]) PyArray_DATA(pyarr18);                                // ARRAY
    arg18 = (int) PyArray_DIM(pyarr18, 0);                           // DIM1
  }
  res20 = SWIG_ConvertPtr(swig_obj[17], &argp20,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res20)) {
    SWIG_exception_fail(SWIG_ArgError(res20), "in method '" "dskw02" "', argument " "20"" of type '" "ConstSpiceDouble []""'"); 
  } 
  arg20 = (ConstSpiceDouble *)(argp20);
  res21 = SWIG_ConvertPtr(swig_obj[18], &argp21,SWIGTYPE_p_ConstSpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res21)) {
    SWIG_exception_fail(SWIG_ArgError(res21), "in method '" "dskw02" "', argument " "21"" of type '" "ConstSpiceInt []""'"); 
  } 
  arg21 = (ConstSpiceInt *)(argp21);
  dskw02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,(ConstSpiceDouble (*)[3])arg17,arg18,(ConstSpiceInt (*)[3])arg19,arg20,arg21);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr16);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr18);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr16);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY2...)
    Py_XDECREF(pyarr18);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskx02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  ConstSpiceDouble *arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr6 = NULL ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  arg5 = &temp5;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("dskx02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "dskx02", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskx02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskx02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskx02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dskx02", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("dskx02", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("dskx02", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("dskx02", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  dskx02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskx02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskxsi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  ConstSpiceInt *arg4 ;
  SpiceDouble arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 ;
  ConstSpiceDouble *arg8 ;
  SpiceDouble *arg9 ;
  SpiceInt *arg10 = (SpiceInt *) 0 ;
  SpiceInt *arg11 ;
  SpiceDouble *arg12 ;
  SpiceDouble *arg13 ;
  SpiceInt *arg14 ;
  SpiceBoolean *arg15 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceInt temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr11 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceBoolean mybool15 ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DLASIZE
    };                               // DIMENSIONS
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg11 = (SpiceInt *) PyArray_DATA(pyarr11);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr11, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      DSKSIZE
    };                               // DIMENSIONS
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg12 = (SpiceDouble *) PyArray_DATA(pyarr12);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr12, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_DSKXSI_DCSIZE
    };                               // DIMENSIONS
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg13 = (SpiceDouble *) PyArray_DATA(pyarr13);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr13, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      SPICE_DSKXSI_ICSIZE
    };                               // DIMENSIONS
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg14 = (SpiceInt *) PyArray_DATA(pyarr14);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr14, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg15 = &mybool15;
  }
  if (!SWIG_Python_UnpackTuple(args, "dskxsi", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskxsi" "', argument " "1"" of type '" "SpiceBoolean""'");
  } 
  arg1 = (SpiceBoolean)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "dskxsi" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_ConstSpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "dskxsi" "', argument " "4"" of type '" "ConstSpiceInt []""'"); 
  } 
  arg4 = (ConstSpiceInt *)(argp4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dskxsi" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("dskxsi", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 0) != (3))) {
        handle_invalid_array_shape_1d("dskxsi", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("dskxsi", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("dskxsi", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  my_dskxsi_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskxsi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg15 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr12);
  }
  {
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr14);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr11);
  }
  {
    Py_XDECREF(pyarr12);
  }
  {
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr14);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskxv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  ConstSpiceInt *arg4 ;
  SpiceDouble arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceInt arg7 ;
  ConstSpiceDouble (*arg8)[3] ;
  SpiceInt arg9 ;
  ConstSpiceDouble (*arg10)[3] ;
  SpiceInt *arg11 = (SpiceInt *) 0 ;
  SpiceInt *arg12 = (SpiceInt *) 0 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  SpiceInt *arg14 = (SpiceInt *) 0 ;
  SpiceBoolean **arg15 = (SpiceBoolean **) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  void *argp14 = 0 ;
  int res14 = 0 ;
  void *argp15 = 0 ;
  int res15 = 0 ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "dskxv", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskxv" "', argument " "1"" of type '" "SpiceBoolean""'");
  } 
  arg1 = (SpiceBoolean)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("dskxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("dskxv", NPY_INT, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceInt *) PyArray_DATA(pyarr3);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "dskxv" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("dskxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("dskxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("dskxv", NPY_DOUBLE, swig_obj[5], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskxv", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr7);                                // ARRAY
    arg7 = (int) PyArray_DIM(pyarr7, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("dskxv", NPY_DOUBLE, swig_obj[6], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr9) && (PyArray_DIM(pyarr9, 1) != (3))) {
        handle_invalid_array_shape_x2d("dskxv", pyarr9, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (ConstSpiceDouble (*)[3]) PyArray_DATA(pyarr9);                                // ARRAY
    arg9 = (int) PyArray_DIM(pyarr9, 0);                           // DIM1
  }
  res11 = SWIG_ConvertPtr(swig_obj[7], &argp11,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "dskxv" "', argument " "11"" of type '" "SpiceInt *""'"); 
  }
  arg11 = (SpiceInt *)(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[8], &argp12,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "dskxv" "', argument " "12"" of type '" "SpiceInt *""'"); 
  }
  arg12 = (SpiceInt *)(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[9], &argp13,SWIGTYPE_p_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "dskxv" "', argument " "13"" of type '" "SpiceDouble **""'"); 
  }
  arg13 = (SpiceDouble **)(argp13);
  res14 = SWIG_ConvertPtr(swig_obj[10], &argp14,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), "in method '" "dskxv" "', argument " "14"" of type '" "SpiceInt *""'"); 
  }
  arg14 = (SpiceInt *)(argp14);
  res15 = SWIG_ConvertPtr(swig_obj[11], &argp15,SWIGTYPE_p_p_SpiceBoolean, 0 |  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), "in method '" "dskxv" "', argument " "15"" of type '" "SpiceBoolean **""'"); 
  }
  arg15 = (SpiceBoolean **)(argp15);
  my_dskxv_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,(ConstSpiceDouble (*)[3])arg8,arg9,(ConstSpiceDouble (*)[3])arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskxv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_dskz02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceInt *arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "dskz02", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "dskz02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceInt IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("dskz02", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (DLASIZE))) {
        handle_invalid_array_shape_1d("dskz02", pyarr2, DLASIZE);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  dskz02_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("dskz02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ednmpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  ConstSpiceDouble *arg4 ;
  SpiceDouble *arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("ednmpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ednmpt", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ednmpt" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ednmpt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ednmpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ednmpt", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 0) != (3))) {
        handle_invalid_array_shape_1d("ednmpt", pyarr4, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
  }
  ednmpt_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ednmpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ednmpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "ednmpt_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("ednmpt_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("ednmpt_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("ednmpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ednmpt_vector", NPY_DOUBLE, swig_obj[3], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  ednmpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ednmpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("ednmpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("ednmpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_edpnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  SpiceDouble arg3 ;
  SpiceDouble arg4 ;
  SpiceDouble *arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("edpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "edpnt", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("edpnt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("edpnt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "edpnt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "edpnt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "edpnt" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  edpnt_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("edpnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_edpnt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "edpnt_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("edpnt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("edpnt_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("edpnt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("edpnt_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  edpnt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("edpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("edpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("edpnt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekacec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyObject *list5 = NULL ;
  char *buffer5 = NULL ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekacec", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekacec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekacec" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekacec" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekacec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekacec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg7 = NULL;
      arg5 = 0;
      arg6 = 0;
      
      list5 = PySequence_List(swig_obj[4]);
      if (!list5) {
        handle_bad_sequence_to_list("ekacec");
        SWIG_fail;
      }
      
      // list5 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list5);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list5, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("ekacec");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("ekacec");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list5, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer5
      buffer5 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer5)) {
          handle_malloc_failure("ekacec");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list5, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer5 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg7 = (ConstSpiceChar *)buffer5;
      arg5 = (int) count;
      arg6 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ekacec" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  ekacec_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekacec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekaced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  ConstSpiceDouble *arg6 ;
  SpiceBoolean arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekaced", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekaced" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekaced" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekaced" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekaced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekaced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ekaced" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ekaced" "', argument " "6"" of type '" "ConstSpiceDouble []""'"); 
  } 
  arg6 = (ConstSpiceDouble *)(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ekaced" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ekaced_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekaced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekacei(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  ConstSpiceInt *arg6 ;
  SpiceBoolean arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekacei", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekacei" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekacei" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekacei" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekacei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekacei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ekacei" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_ConstSpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ekacei" "', argument " "6"" of type '" "ConstSpiceInt []""'"); 
  } 
  arg6 = (ConstSpiceInt *)(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ekacei" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ekacei_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekacei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekaclc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceInt *arg6 ;
  ConstSpiceBoolean *arg7 ;
  ConstSpiceInt *arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyObject *swig_obj[8] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekaclc", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekaclc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekaclc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("ekaclc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekaclc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ekaclc" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "ekaclc" "', argument " "5"" of type '" "ConstSpiceChar *""'"); 
  }
  arg5 = (ConstSpiceChar *)(argp5);
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("ekaclc", NPY_INT, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceInt *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  {
    //      (ConstSpiceBoolean *IN_ARRAY1)
    //      (ConstSpiceBoolean IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ekaclc", NPY_INT, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceBoolean *) PyArray_DATA(pyarr7);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("ekaclc", NPY_INT, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceInt *) PyArray_DATA(pyarr8);                          // ARRAY
  }
  my_ekaclc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekaclc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekacld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg4 ;
  ConstSpiceInt *arg5 ;
  ConstSpiceBoolean *arg6 ;
  ConstSpiceInt *arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekacld", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekacld" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekacld" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("ekacld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekacld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ekacld", NPY_INT, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("ekacld", NPY_INT, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceInt *) PyArray_DATA(pyarr5);                          // ARRAY
  }
  {
    //      (ConstSpiceBoolean *IN_ARRAY1)
    //      (ConstSpiceBoolean IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("ekacld", NPY_INT, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceBoolean *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ekacld", NPY_INT, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceInt *) PyArray_DATA(pyarr7);                          // ARRAY
  }
  my_ekacld_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekacld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekacli(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceInt *arg4 ;
  ConstSpiceInt *arg5 ;
  ConstSpiceBoolean *arg6 ;
  ConstSpiceInt *arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekacli", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekacli" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekacli" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("ekacli");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekacli");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("ekacli", NPY_INT, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceInt *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[4], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("ekacli", NPY_INT, swig_obj[4], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceInt *) PyArray_DATA(pyarr5);                          // ARRAY
  }
  {
    //      (ConstSpiceBoolean *IN_ARRAY1)
    //      (ConstSpiceBoolean IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("ekacli", NPY_INT, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceBoolean *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("ekacli", NPY_INT, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceInt *) PyArray_DATA(pyarr7);                          // ARRAY
  }
  my_ekacli_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekacli");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekappr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  if (!SWIG_Python_UnpackTuple(args, "ekappr", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekappr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekappr" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ekappr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekappr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekbseg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceInt arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  PyObject *list3 = NULL ;
  char *buffer3 = NULL ;
  int val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SpiceInt temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[5] ;
  
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "ekbseg", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekbseg" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ekbseg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekbseg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg5 = NULL;
      arg3 = 0;
      arg4 = 0;
      
      list3 = PySequence_List(swig_obj[2]);
      if (!list3) {
        handle_bad_sequence_to_list("ekbseg");
        SWIG_fail;
      }
      
      // list3 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list3);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list3, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("ekbseg");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("ekbseg");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list3, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer3
      buffer3 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer3)) {
          handle_malloc_failure("ekbseg");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list3, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer3 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg5 = (ConstSpiceChar *)buffer3;
      arg3 = (int) count;
      arg4 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  ecode6 = SWIG_AsVal_int(swig_obj[3], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ekbseg" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  res7 = SWIG_ConvertPtr(swig_obj[4], &argp7,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ekbseg" "', argument " "7"" of type '" "ConstSpiceChar *""'"); 
  }
  arg7 = (ConstSpiceChar *)(argp7);
  ekbseg_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekbseg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    Py_XDECREF(list3);
    PyMem_Free((void *) buffer3);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list3);
    PyMem_Free((void *) buffer3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekccnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekccnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekccnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ekccnt_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekccnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekcii(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceBoolean *arg9 = (SpiceBoolean *) 0 ;
  SpiceBoolean *arg10 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceInt temp8 ;
  int res8 = SWIG_TMPOBJ ;
  SpiceBoolean temp9 ;
  int res9 = SWIG_TMPOBJ ;
  SpiceBoolean temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("ekcii");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  arg9 = &temp9;
  arg10 = &temp10;
  if (!SWIG_Python_UnpackTuple(args, "ekcii", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekcii");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekcii");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekcii" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  my_ekcii_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekcii");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceBoolean, new_flags));
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceBoolean, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ekcls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekdelr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekdelr", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekdelr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekdelr" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekdelr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekdelr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekdelr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekffld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekffld", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekffld" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekffld" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (SpiceInt *IN_ARRAY1)
    //      (SpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("ekffld", NPY_INT, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (SpiceInt *) PyArray_DATA(pyarr3);                          // ARRAY
  }
  ekffld_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekffld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (SpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekfind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  SpiceChar *arg4 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceBoolean temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 = 0 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  {
    //      (char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (char *) PyMem_Malloc((dim14 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("ekfind");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg4 = buffer4;                                                // STRING
    //  $2 = dim14;                                                  // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekfind");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekfind");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_ekfind_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekfind");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceBoolean, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekgc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceBoolean mybool6 ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, COLLEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("ekgc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekgc", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekgc" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekgc" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekgc" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekgc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekgc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekgd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceBoolean mybool5 ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekgd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekgd" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekgd" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekgd" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekgd_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekgd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekgi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceBoolean *arg5 = (SpiceBoolean *) 0 ;
  SpiceBoolean *arg6 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceBoolean mybool5 ;
  SpiceBoolean mybool6 ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg5 = &mybool5;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg6 = &mybool6;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekgi", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekgi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekgi" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekgi" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekgi_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekgi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg5 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg6 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekifld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceInt arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  SpiceInt *arg10 = (SpiceInt *) 0 ;
  SpiceInt *arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *list4 = NULL ;
  char *buffer4 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SpiceInt temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr10 = NULL ;
  int size10[1] ;
  PyObject *swig_obj[6] ;
  
  arg9 = &temp9;
  {
    //      (int *SIZE1, SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      MAXROWS
    };                               // ARRAY
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("ekifld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg11 = (SpiceInt *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    arg10 = &size10[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ekifld", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekifld" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ekifld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekifld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekifld" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg6 = NULL;
      arg4 = 0;
      arg5 = 0;
      
      list4 = PySequence_List(swig_obj[3]);
      if (!list4) {
        handle_bad_sequence_to_list("ekifld");
        SWIG_fail;
      }
      
      // list4 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list4);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list4, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("ekifld");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("ekifld");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list4, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer4
      buffer4 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer4)) {
          handle_malloc_failure("ekifld");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list4, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer4 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg6 = (ConstSpiceChar *)buffer4;
      arg4 = (int) count;
      arg5 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  ecode7 = SWIG_AsVal_int(swig_obj[4], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ekifld" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  res8 = SWIG_ConvertPtr(swig_obj[5], &argp8,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "ekifld" "', argument " "8"" of type '" "ConstSpiceChar *""'"); 
  }
  arg8 = (ConstSpiceChar *)(argp8);
  my_ekifld_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekifld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size10[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr10, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    Py_XDECREF(list4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list4);
    PyMem_Free((void *) buffer4);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekinsr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekinsr", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekinsr" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekinsr" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekinsr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekinsr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekinsr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eklef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("eklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("eklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  eklef_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eknelt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "eknelt", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "eknelt" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "eknelt" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  result = eknelt_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eknelt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_eknseg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  SpiceInt result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "eknseg" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  result = eknseg_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("eknseg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekntab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt temp1 ;
  int res1 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  if (!SWIG_Python_UnpackTuple(args, "ekntab", 0, 0, 0)) SWIG_fail;
  ekntab_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekntab");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "ekopn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ekopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekopn" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ekopn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekopr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ekopr_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekopr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekops(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt *arg1 = (SpiceInt *) 0 ;
  SpiceInt temp1 ;
  int res1 = SWIG_TMPOBJ ;
  
  arg1 = &temp1;
  if (!SWIG_Python_UnpackTuple(args, "ekops", 0, 0, 0)) SWIG_fail;
  ekops_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekops");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res1)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg1)));
  } else {
    int new_flags = SWIG_IsNewObj(res1) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg1), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekopw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ekopw_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekopw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekpsel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 ;
  SpiceInt *arg4 ;
  int *arg5 = (int *) 0 ;
  SpiceInt *arg6 ;
  int *arg7 = (int *) 0 ;
  SpiceInt *arg8 ;
  int *arg9 = (int *) 0 ;
  char (*arg10)[NAMELEN] ;
  int *arg11 = (int *) 0 ;
  char (*arg12)[NAMELEN] ;
  int *arg13 = (int *) 0 ;
  SpiceBoolean *arg14 = (SpiceBoolean *) 0 ;
  SpiceChar *arg15 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int size2[1] ;
  PyArrayObject *pyarr4 = NULL ;
  int size4[1] ;
  PyArrayObject *pyarr6 = NULL ;
  int size6[1] ;
  PyArrayObject *pyarr8 = NULL ;
  int size8[1] ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  void *argp12 = 0 ;
  int res12 = 0 ;
  void *argp13 = 0 ;
  int res13 = 0 ;
  SpiceBoolean temp14 ;
  int res14 = SWIG_TMPOBJ ;
  SpiceChar *buffer15 = NULL ;
  size_t dim115 = 0 ;
  int alloc15 = 0 ;
  PyObject *swig_obj[5] ;
  
  {
    //      (int *SIZE1, SpiceInt OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      CLAUSES
    };                               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceInt *) PyArray_DATA(pyarr2);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
    arg2 = &size2[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      CLAUSES
    };                               // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceInt *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    arg5 = &size4[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      CLAUSES
    };                               // ARRAY
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceInt *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    arg7 = &size6[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      CLAUSES
    };                               // ARRAY
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceInt *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    arg9 = &size8[0];                                              // SIZE1
  }
  arg14 = &temp14;
  {
    //      (char OUT_STRING[ANY])
    
    dim115 = max(1, MESSAGELEN);
    buffer15 = (char *) PyMem_Malloc((dim115 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc15 = SWIG_NEWOBJ;
    
    buffer15[0] = '\0';   // String begins empty
    arg15 = buffer15;                                                // STRING
    //  $2 = dim115;                                                  // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "ekpsel", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  res10 = SWIG_ConvertPtr(swig_obj[1], &argp10,SWIGTYPE_p_a_NAMELEN__char, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), "in method '" "ekpsel" "', argument " "10"" of type '" "char [CLAUSES][NAMELEN]""'"); 
  } 
  arg10 = (char (*)[NAMELEN])(argp10);
  res11 = SWIG_ConvertPtr(swig_obj[2], &argp11,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), "in method '" "ekpsel" "', argument " "11"" of type '" "int *""'"); 
  }
  arg11 = (int *)(argp11);
  res12 = SWIG_ConvertPtr(swig_obj[3], &argp12,SWIGTYPE_p_a_NAMELEN__char, 0 |  0 );
  if (!SWIG_IsOK(res12)) {
    SWIG_exception_fail(SWIG_ArgError(res12), "in method '" "ekpsel" "', argument " "12"" of type '" "char [CLAUSES][NAMELEN]""'"); 
  } 
  arg12 = (char (*)[NAMELEN])(argp12);
  res13 = SWIG_ConvertPtr(swig_obj[4], &argp13,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), "in method '" "ekpsel" "', argument " "13"" of type '" "int *""'"); 
  }
  arg13 = (int *)(argp13);
  my_ekpsel_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(char (*)[NAMELEN])arg10,arg11,(char (*)[NAMELEN])arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekpsel");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size2[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr2, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size4[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size6[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr6, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size8[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr8, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  if (SWIG_IsTmpObj(res14)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg14)));
  } else {
    int new_flags = SWIG_IsNewObj(res14) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg14), SWIGTYPE_p_SpiceBoolean, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer15[dim115-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer15);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc15)) {
      PyMem_Free((void *) buffer15);
    }
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc15)) {
      PyMem_Free((void *) buffer15);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekrcec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  char (*arg7)[COLLEN] ;
  SpiceBoolean *arg8 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  SpiceBoolean mybool8 ;
  PyObject *swig_obj[7] ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg8 = &mybool8;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekrcec", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekrcec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekrcec" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekrcec" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekrcec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekrcec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ekrcec" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ekrcec" "', argument " "6"" of type '" "SpiceInt *""'"); 
  }
  arg6 = (SpiceInt *)(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_a_COLLEN__char, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ekrcec" "', argument " "7"" of type '" "char [MAXVALS][COLLEN]""'"); 
  } 
  arg7 = (char (*)[COLLEN])(argp7);
  ekrcec_c(arg1,arg2,arg3,arg4,arg5,arg6,(char (*)[COLLEN])arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekrcec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg8 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekrced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int size5[1] ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      MAXVALS
    };                               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("ekrced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    arg5 = &size5[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekrced", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekrced" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekrced" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekrced" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekrced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekrced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ekrced_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekrced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size5[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekrcei(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceInt *arg6 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int size5[1] ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      MAXVALS
    };                               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("ekrcei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceInt *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    arg5 = &size5[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "ekrcei", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekrcei" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekrcei" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekrcei" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekrcei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekrcei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ekrcei_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekrcei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size5[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekssum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int *arg4 = (int *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceChar (*arg6)[NAMELEN] ;
  int *arg7 = (int *) 0 ;
  SpiceInt *arg8 ;
  int *arg9 = (int *) 0 ;
  SpiceInt *arg10 ;
  int *arg11 = (int *) 0 ;
  SpiceInt *arg12 ;
  int *arg13 = (int *) 0 ;
  SpiceInt *arg14 ;
  int *arg15 = (int *) 0 ;
  SpiceBoolean *arg16 ;
  int *arg17 = (int *) 0 ;
  SpiceBoolean *arg18 ;
  int *arg19 = (int *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 = 0 ;
  int alloc3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  int size8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  int size10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  int size12[1] ;
  PyArrayObject *pyarr14 = NULL ;
  int size14[1] ;
  PyArrayObject *pyarr16 = NULL ;
  int size16[1] ;
  PyArrayObject *pyarr18 = NULL ;
  int size18[1] ;
  PyObject *swig_obj[5] ;
  
  {
    //      (char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (char *) PyMem_Malloc((dim13 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg3 = buffer3;                                                // STRING
    //  $2 = dim13;                                                  // DIM1
  }
  arg5 = &temp5;
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (SpiceInt *) PyArray_DATA(pyarr8);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
    arg9 = &size8[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceInt *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    arg11 = &size10[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg12 = (SpiceInt *) PyArray_DATA(pyarr12);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr12, 0);                            // DIM1
    arg13 = &size12[0];                                              // SIZE1
  }
  {
    //      (SpiceInt OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg14 = (SpiceInt *) PyArray_DATA(pyarr14);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr14, 0);                            // DIM1
    arg15 = &size14[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg16 = (SpiceBoolean *) PyArray_DATA(pyarr16);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr16, 0);                            // DIM1
    arg17 = &size16[0];                                              // SIZE1
  }
  {
    //      (SpiceBoolean OUT_ARRAY1[ANY], int *SIZE1)
    
    npy_intp dims[1] = {
      SPICE_EK_MXCLSG
    };                               // ARRAY
    pyarr18 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_INT);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr18)) {
        handle_malloc_failure("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg18 = (SpiceBoolean *) PyArray_DATA(pyarr18);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr18, 0);                            // DIM1
    arg19 = &size18[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "ekssum", 5, 5, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekssum" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekssum" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "ekssum" "', argument " "4"" of type '" "int *""'"); 
  }
  arg4 = (int *)(argp4);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_a_NAMELEN__SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "ekssum" "', argument " "6"" of type '" "SpiceChar [SPICE_EK_MXCLSG][NAMELEN]""'"); 
  } 
  arg6 = (SpiceChar (*)[NAMELEN])(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[4], &argp7,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "ekssum" "', argument " "7"" of type '" "int *""'"); 
  }
  arg7 = (int *)(argp7);
  my_ekssum_c(arg1,arg2,arg3,arg4,arg5,(SpiceChar (*)[NAMELEN])arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekssum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size8[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr8, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr8);
    // AppendOutput steals the reference to the argument.
    pyarr8 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size10[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr10, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size12[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr12, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size14[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr14, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size16[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr16, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr16);
    // AppendOutput steals the reference to the argument.
    pyarr16 = NULL;
  }
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size18[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr18, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr18);
    // AppendOutput steals the reference to the argument.
    pyarr18 = NULL;
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
  }
  {
    Py_XDECREF(pyarr14);
  }
  {
    Py_XDECREF(pyarr16);
  }
  {
    Py_XDECREF(pyarr18);
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  {
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr12);
  }
  {
    Py_XDECREF(pyarr14);
  }
  {
    Py_XDECREF(pyarr16);
  }
  {
    Py_XDECREF(pyarr18);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ektnam(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("ektnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ektnam" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ektnam_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ektnam");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekucec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceInt arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceBoolean arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  PyObject *list5 = NULL ;
  char *buffer5 = NULL ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekucec", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekucec" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekucec" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekucec" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekucec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekucec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg7 = NULL;
      arg5 = 0;
      arg6 = 0;
      
      list5 = PySequence_List(swig_obj[4]);
      if (!list5) {
        handle_bad_sequence_to_list("ekucec");
        SWIG_fail;
      }
      
      // list5 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list5);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list5, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("ekucec");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("ekucec");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list5, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer5
      buffer5 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer5)) {
          handle_malloc_failure("ekucec");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list5, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer5 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg7 = (ConstSpiceChar *)buffer5;
      arg5 = (int) count;
      arg6 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  ecode8 = SWIG_AsVal_int(swig_obj[5], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "ekucec" "', argument " "8"" of type '" "SpiceBoolean""'");
  } 
  arg8 = (SpiceBoolean)(val8);
  ekucec_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekucec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekuced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  ConstSpiceDouble *arg6 ;
  SpiceBoolean arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekuced", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekuced" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekuced" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekuced" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekuced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekuced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ekuced" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("ekuced", NPY_INT, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ekuced" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ekuced_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekuced");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekucei(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  ConstSpiceInt *arg6 ;
  SpiceBoolean arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  int val7 ;
  int ecode7 = 0 ;
  PyObject *swig_obj[7] ;
  
  if (!SWIG_Python_UnpackTuple(args, "ekucei", 7, 7, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekucei" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ekucei" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ekucei" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("ekucei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ekucei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ekucei" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("ekucei", NPY_INT, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceInt *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ekucei" "', argument " "7"" of type '" "SpiceBoolean""'");
  } 
  arg7 = (SpiceBoolean)(val7);
  ekucei_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekucei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ekuef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ekuef" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ekuef_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ekuef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_evsgp4(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("evsgp4");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "evsgp4", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "evsgp4" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("evsgp4", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (8))) {
        handle_invalid_array_shape_1d("evsgp4", pyarr2, 8);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("evsgp4", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (10))) {
        handle_invalid_array_shape_1d("evsgp4", pyarr3, 10);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  evsgp4_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("evsgp4");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_evsgp4_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "evsgp4_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("evsgp4_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("evsgp4_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr3) == 1) {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = 0;                                                 // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 0);                        // DIM2
    } else {
      arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                    // ARRAY
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
      arg5 = (int) PyArray_DIM(pyarr3, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("evsgp4_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr6) == 1) {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = 0;                                                 // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 0);                        // DIM2
    } else {
      arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                    // ARRAY
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
      arg8 = (int) PyArray_DIM(pyarr6, 1);                        // DIM2
    }
  }
  evsgp4_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("evsgp4_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("evsgp4_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    if (dimsize9[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("evsgp4_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_esrchc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "esrchc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("esrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("esrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("esrchc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("esrchc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("esrchc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("esrchc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  result = esrchc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("esrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_getelm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr6 = NULL ;
  PyObject *swig_obj[2] ;
  
  arg5 = &temp5;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      10
    };                               // DIMENSIONS
    pyarr6 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr6)) {
        handle_malloc_failure("getelm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr6);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "getelm", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "getelm" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("getelm");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("getelm");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("getelm");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("getelm");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  my_getelm_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("getelm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr6);
    // AppendOutput steals the reference to the argument.
    pyarr6 = NULL;
  }
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    Py_XDECREF(pyarr6);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_getfat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceChar *arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 = 0 ;
  int alloc3 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (char *) PyMem_Malloc((dim12 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("getfat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg2 = buffer2;                                                // STRING
    //  $2 = dim12;                                                  // DIM1
  }
  {
    //      (char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (char *) PyMem_Malloc((dim13 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("getfat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg3 = buffer3;                                                // STRING
    //  $2 = dim13;                                                  // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("getfat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("getfat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_getfat_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("getfat");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_getfvn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceChar *arg2 ;
  SpiceChar *arg3 ;
  SpiceDouble *arg4 ;
  SpiceDouble (*arg5)[3] ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 = 0 ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (char *) PyMem_Malloc((dim12 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg2 = buffer2;                                                // STRING
    //  $2 = dim12;                                                  // DIM1
  }
  {
    //      (char OUT_STRING[ANY])
    
    dim13 = max(1, NAMELEN);
    buffer3 = (char *) PyMem_Malloc((dim13 + 1) * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg3 = buffer3;                                                // STRING
    //  $2 = dim13;                                                  // DIM1
  }
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      FOVSHAPE, 3
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    arg6 = &dimsize5[0];                                           // SIZE1
    //  $5 = &dimsize5[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_getfvn_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[3])arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("getfvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  {
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfdist(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble (*arg10)[2] ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize10[0] = (int) dims[0];
    dimsize10[1] = (int) dims[1];
    
    arg10 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr10);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr10, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr10, 1);                           // DIM2
    arg11 = &dimsize10[0];                                           // SIZE1
    //  $5 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfdist", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gfdist" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gfdist" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gfdist" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gfdist" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gfdist" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  my_gfdist_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(SpiceDouble (*)[2])arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfdist");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr10, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfevnt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  ConstSpiceInt *arg7 = (ConstSpiceInt *) 0 ;
  ConstSpiceBoolean *arg8 = (ConstSpiceBoolean *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceBoolean arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble arg15 ;
  SpiceDouble (*arg16)[2] ;
  int *arg17 = (int *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  int alloc9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  int val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyArrayObject *pyarr16 = NULL ;
  int dimsize16[2] ;
  PyObject *swig_obj[15] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize16[0] = (int) dims[0];
    dimsize16[1] = (int) dims[1];
    
    arg16 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr16);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr16, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr16, 1);                           // DIM2
    arg17 = &dimsize16[0];                                           // SIZE1
    //  $5 = &dimsize16[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfevnt", 15, 15, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gfevnt" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gfevnt" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gfevnt" "', argument " "4"" of type '" "ConstSpiceChar *""'"); 
  }
  arg4 = (ConstSpiceChar *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[4], &argp5,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gfevnt" "', argument " "5"" of type '" "ConstSpiceChar *""'"); 
  }
  arg5 = (ConstSpiceChar *)(argp5);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("gfevnt", NPY_DOUBLE, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
  }
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("gfevnt", NPY_INT, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceInt *) PyArray_DATA(pyarr7);                          // ARRAY
  }
  {
    //      (ConstSpiceBoolean *IN_ARRAY1)
    //      (ConstSpiceBoolean IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("gfevnt", NPY_INT, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceBoolean *) PyArray_DATA(pyarr8);                          // ARRAY
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfevnt" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfevnt" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfevnt" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_int(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfevnt" "', argument " "13"" of type '" "SpiceBoolean""'");
  } 
  arg13 = (SpiceBoolean)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gfevnt" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "gfevnt" "', argument " "15"" of type '" "SpiceDouble""'");
  } 
  arg15 = (SpiceDouble)(val15);
  my_gfevnt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(SpiceDouble (*)[2])arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfevnt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    npy_intp dims[2] = {
      dimsize16[0], dimsize16[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr16, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
    // AppendOutput steals the reference to the argument.
    pyarr16 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceBoolean ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gffove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceBoolean arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble (*arg13)[2] ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyArrayObject *pyarr13 = NULL ;
  int dimsize13[2] ;
  PyObject *swig_obj[12] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize13[0] = (int) dims[0];
    dimsize13[1] = (int) dims[1];
    
    arg13 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr13);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr13, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr13, 1);                           // DIM2
    arg14 = &dimsize13[0];                                           // SIZE1
    //  $5 = &dimsize13[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gffove", 12, 12, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("gffove", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("gffove", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gffove" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gffove" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gffove" "', argument " "10"" of type '" "SpiceBoolean""'");
  } 
  arg10 = (SpiceBoolean)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gffove" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gffove" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  my_gffove_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(SpiceDouble (*)[2])arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gffove");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr13, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr13);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfilum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble (*arg15)[2] ;
  int *arg16 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  int alloc9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyArrayObject *pyarr15 = NULL ;
  int dimsize15[2] ;
  PyObject *swig_obj[14] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize15[0] = (int) dims[0];
    dimsize15[1] = (int) dims[1];
    
    arg15 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr15);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr15, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr15, 1);                           // DIM2
    arg16 = &dimsize15[0];                                           // SIZE1
    //  $5 = &dimsize15[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfilum", 14, 14, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("gfilum", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (3))) {
        handle_invalid_array_shape_1d("gfilum", pyarr8, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfilum" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfilum" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfilum" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfilum" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gfilum" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  my_gfilum_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(SpiceDouble (*)[2])arg15,arg16);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfilum");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize15[0], dimsize15[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr15, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
    // AppendOutput steals the reference to the argument.
    pyarr15 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr15);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfocce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceBoolean arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble (*arg15)[2] ;
  int *arg16 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyArrayObject *pyarr15 = NULL ;
  int dimsize15[2] ;
  PyObject *swig_obj[14] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize15[0] = (int) dims[0];
    dimsize15[1] = (int) dims[1];
    
    arg15 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr15);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr15, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr15, 1);                           // DIM2
    arg16 = &dimsize15[0];                                           // SIZE1
    //  $5 = &dimsize15[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfocce", 14, 14, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  res7 = SWIG_ConvertPtr(swig_obj[6], &argp7,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "gfocce" "', argument " "7"" of type '" "ConstSpiceChar *""'"); 
  }
  arg7 = (ConstSpiceChar *)(argp7);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfocce" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfocce" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_int(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfocce" "', argument " "12"" of type '" "SpiceBoolean""'");
  } 
  arg12 = (SpiceBoolean)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfocce" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gfocce" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  my_gfocce_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(SpiceDouble (*)[2])arg15,arg16);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfocce");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize15[0], dimsize15[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr15, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
    // AppendOutput steals the reference to the argument.
    pyarr15 = NULL;
  }
  {
    Py_XDECREF(pyarr15);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfoclt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble (*arg13)[2] ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyArrayObject *pyarr13 = NULL ;
  int dimsize13[2] ;
  PyObject *swig_obj[12] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize13[0] = (int) dims[0];
    dimsize13[1] = (int) dims[1];
    
    arg13 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr13);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr13, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr13, 1);                           // DIM2
    arg14 = &dimsize13[0];                                           // SIZE1
    //  $5 = &dimsize13[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfoclt", 12, 12, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfoclt" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfoclt" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfoclt" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  my_gfoclt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(SpiceDouble (*)[2])arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfoclt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr13, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    Py_XDECREF(pyarr13);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfpa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble arg10 ;
  SpiceDouble (*arg11)[2] ;
  int *arg12 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  int dimsize11[2] ;
  PyObject *swig_obj[10] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize11[0] = (int) dims[0];
    dimsize11[1] = (int) dims[1];
    
    arg11 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr11);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr11, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr11, 1);                           // DIM2
    arg12 = &dimsize11[0];                                           // SIZE1
    //  $5 = &dimsize11[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfpa", 10, 10, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gfpa" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gfpa" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gfpa" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gfpa" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfpa" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  my_gfpa_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,(SpiceDouble (*)[2])arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfpa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize11[0], dimsize11[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr11, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
    // AppendOutput steals the reference to the argument.
    pyarr11 = NULL;
  }
  {
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfposc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble (*arg13)[2] ;
  int *arg14 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyArrayObject *pyarr13 = NULL ;
  int dimsize13[2] ;
  PyObject *swig_obj[12] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize13[0] = (int) dims[0];
    dimsize13[1] = (int) dims[1];
    
    arg13 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr13);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr13, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr13, 1);                           // DIM2
    arg14 = &dimsize13[0];                                           // SIZE1
    //  $5 = &dimsize13[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfposc", 12, 12, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gfposc" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gfposc" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfposc" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfposc" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfposc" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  my_gfposc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(SpiceDouble (*)[2])arg13,arg14);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfposc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr13, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    Py_XDECREF(pyarr13);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr13);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfrfov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble (*arg9)[2] ;
  int *arg10 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  int dimsize9[2] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize9[0] = (int) dims[0];
    dimsize9[1] = (int) dims[1];
    
    arg9 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr9);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr9, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr9, 1);                           // DIM2
    arg10 = &dimsize9[0];                                           // SIZE1
    //  $5 = &dimsize9[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfrfov", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("gfrfov", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("gfrfov", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gfrfov" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gfrfov" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gfrfov" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  my_gfrfov_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,(SpiceDouble (*)[2])arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfrfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize9[0], dimsize9[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr9, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfrr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble (*arg10)[2] ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize10[0] = (int) dims[0];
    dimsize10[1] = (int) dims[1];
    
    arg10 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr10);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr10, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr10, 1);                           // DIM2
    arg11 = &dimsize10[0];                                           // SIZE1
    //  $5 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfrr", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gfrr" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gfrr" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gfrr" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gfrr" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gfrr" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  my_gfrr_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(SpiceDouble (*)[2])arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfrr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr10, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfsep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble (*arg15)[2] ;
  int *arg16 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  PyArrayObject *pyarr15 = NULL ;
  int dimsize15[2] ;
  PyObject *swig_obj[14] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize15[0] = (int) dims[0];
    dimsize15[1] = (int) dims[1];
    
    arg15 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr15);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr15, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr15, 1);                           // DIM2
    arg16 = &dimsize15[0];                                           // SIZE1
    //  $5 = &dimsize15[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfsep", 14, 14, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfsep" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfsep" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfsep" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfsep" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gfsep" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  my_gfsep_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,(SpiceDouble (*)[2])arg15,arg16);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize15[0], dimsize15[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr15, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
    // AppendOutput steals the reference to the argument.
    pyarr15 = NULL;
  }
  {
    Py_XDECREF(pyarr15);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfsntc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg10 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble arg15 ;
  SpiceDouble (*arg16)[2] ;
  int *arg17 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  int alloc10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyArrayObject *pyarr16 = NULL ;
  int dimsize16[2] ;
  PyObject *swig_obj[15] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize16[0] = (int) dims[0];
    dimsize16[1] = (int) dims[1];
    
    arg16 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr16);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr16, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr16, 1);                           // DIM2
    arg17 = &dimsize16[0];                                           // SIZE1
    //  $5 = &dimsize16[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfsntc", 15, 15, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("gfsntc", NPY_DOUBLE, swig_obj[6], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr7) && (PyArray_DIM(pyarr7, 0) != (3))) {
        handle_invalid_array_shape_1d("gfsntc", pyarr7, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[9]) : !PyString_Check(swig_obj[9])) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[9], (char **)&arg10, NULL, &alloc10);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfsntc" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfsntc" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfsntc" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "gfsntc" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "gfsntc" "', argument " "15"" of type '" "SpiceDouble""'");
  } 
  arg15 = (SpiceDouble)(val15);
  my_gfsntc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,(SpiceDouble (*)[2])arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfsntc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize16[0], dimsize16[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr16, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
    // AppendOutput steals the reference to the argument.
    pyarr16 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr16);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr16);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfstol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  double val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gfstol" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  gfstol_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfstol");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_gfsubc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg9 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble (*arg14)[2] ;
  int *arg15 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyArrayObject *pyarr14 = NULL ;
  int dimsize14[2] ;
  PyObject *swig_obj[13] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr14 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize14[0] = (int) dims[0];
    dimsize14[1] = (int) dims[1];
    
    arg14 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr14);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr14, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr14, 1);                           // DIM2
    arg15 = &dimsize14[0];                                           // SIZE1
    //  $5 = &dimsize14[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gfsubc", 13, 13, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gfsubc" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "gfsubc" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "gfsubc" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "gfsubc" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "gfsubc" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  my_gfsubc_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(SpiceDouble (*)[2])arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gfsubc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize14[0], dimsize14[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr14, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    Py_XDECREF(pyarr14);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr14);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_gftfov(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg7 ;
  SpiceDouble arg8 ;
  SpiceDouble arg9 ;
  SpiceDouble (*arg10)[2] ;
  int *arg11 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  double val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY], int *SIZE1)
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize10[0] = (int) dims[0];
    dimsize10[1] = (int) dims[1];
    
    arg10 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr10);                        // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr10, 0);                           // DIM1
    //  $4 = (int) PyArray_DIM(pyarr10, 1);                           // DIM2
    arg11 = &dimsize10[0];                                           // SIZE1
    //  $5 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "gftfov", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gftfov" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "gftfov" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_double(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "gftfov" "', argument " "9"" of type '" "SpiceDouble""'");
  } 
  arg9 = (SpiceDouble)(val9);
  my_gftfov_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(SpiceDouble (*)[2])arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("gftfov");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr10, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hrmesp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[4] ;
  
  arg6 = &temp6;
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "hrmesp", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "hrmesp" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "hrmesp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("hrmesp", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "hrmesp" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  my_hrmesp_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("hrmesp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hrmesp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "hrmesp_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("hrmesp_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("hrmesp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("hrmesp_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("hrmesp_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  hrmesp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("hrmesp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("hrmesp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("hrmesp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("hrmesp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("hrmesp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("hrmesp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("hrmesp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hrmint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceInt arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceDouble *arg8 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val6 ;
  int ecode6 = 0 ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceDouble temp8 ;
  int res8 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg7 = &temp7;
  arg8 = &temp8;
  if (!SWIG_Python_UnpackTuple(args, "hrmint", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("hrmint", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY2, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("hrmint", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                                // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
    arg5 = (int) PyArray_DIM(pyarr3, 1);                           // DIM2
  }
  ecode6 = SWIG_AsVal_double(swig_obj[2], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "hrmint" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  my_hrmint_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("hrmint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hrmint_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "hrmint_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("hrmint_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("hrmint_vector", NPY_DOUBLE, swig_obj[1], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 2) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 1);                        // DIM3
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
      arg7 = (int) PyArray_DIM(pyarr4, 2);                        // DIM3
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("hrmint_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  hrmint_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("hrmint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("hrmint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("hrmint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("hrmint_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("hrmint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("hrmint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("hrmint_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_hx2dp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  int alloc1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceBoolean mybool3 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("hx2dp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("hx2dp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("hx2dp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_hx2dp_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("hx2dp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_invstm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble (*arg1)[6] ;
  SpiceDouble (*arg2)[6] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("invstm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY2[ANY][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invstm", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,603,TEST_INVALID_ARRAY_SHAPE_2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6) || PyArray_DIM(pyarr1, 1) != (6))) {
        handle_invalid_array_shape_2d("invstm", pyarr1, 6, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble (*)[6]) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
    //  $3 = (int) PyArray_DIM(pyarr1, 1);                            // DIM2
  }
  invstm_c((ConstSpiceDouble (*)[6])arg1,(SpiceDouble (*)[6])arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invstm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_invstm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  int *arg6 = (int *) 0 ;
  int *arg7 = (int *) 0 ;
  int *arg8 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[3] ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
    arg7 = &dimsize5[1];                                           // SIZE2
    arg8 = &dimsize5[2];                                           // SIZE3
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY23, int DIM1, int DIM2, int DIM3)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 3, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("invstm_vector", NPY_DOUBLE, swig_obj[0], 2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 2) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 1);                        // DIM3
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
      arg4 = (int) PyArray_DIM(pyarr1, 2);                        // DIM3
    }
  }
  invstm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("invstm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("invstm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize5[0], dimsize5[1], dimsize5[2]
    };
    if (dims[0] == 0) {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr5 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("invstm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5,
      PyArray_SIZE(pyarr5) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    pyarr5 = NULL;
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isrchc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "isrchc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("isrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("isrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("isrchc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("isrchc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("isrchc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("isrchc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  result = isrchc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isrchc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isrchd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "isrchd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isrchd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("isrchd", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = isrchd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isrchd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isrchi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "isrchi", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "isrchi" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("isrchi", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = isrchi_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isrchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_isordv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 ;
  SpiceInt arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyObject *swig_obj[2] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "isordv", 2, 2, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstSpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "isordv" "', argument " "1"" of type '" "ConstSpiceInt []""'"); 
  } 
  arg1 = (ConstSpiceInt *)(argp1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "isordv" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  result = isordv_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("isordv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_iswhsp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  SpiceBoolean result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("iswhsp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("iswhsp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = iswhsp_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("iswhsp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kclear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  
  if (!SWIG_Python_UnpackTuple(args, "kclear", 0, 0, 0)) SWIG_fail;
  kclear_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("kclear");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kdata(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 = (SpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 = (SpiceChar *) 0 ;
  SpiceInt arg7 ;
  SpiceChar *arg8 = (SpiceChar *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  SpiceBoolean *arg10 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  SpiceInt temp9 ;
  int res9 = SWIG_TMPOBJ ;
  SpiceBoolean mybool10 ;
  PyObject *swig_obj[8] ;
  
  arg9 = &temp9;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg10 = &mybool10;
  }
  if (!SWIG_Python_UnpackTuple(args, "kdata", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "kdata" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("kdata");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("kdata");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "kdata" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  res4 = SWIG_ConvertPtr(swig_obj[3], &argp4,SWIGTYPE_p_SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "kdata" "', argument " "4"" of type '" "SpiceChar *""'"); 
  }
  arg4 = (SpiceChar *)(argp4);
  ecode5 = SWIG_AsVal_int(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "kdata" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[5], &argp6,SWIGTYPE_p_SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "kdata" "', argument " "6"" of type '" "SpiceChar *""'"); 
  }
  arg6 = (SpiceChar *)(argp6);
  ecode7 = SWIG_AsVal_int(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "kdata" "', argument " "7"" of type '" "SpiceInt""'");
  } 
  arg7 = (SpiceInt)(val7);
  res8 = SWIG_ConvertPtr(swig_obj[7], &argp8,SWIGTYPE_p_SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), "in method '" "kdata" "', argument " "8"" of type '" "SpiceChar *""'"); 
  }
  arg8 = (SpiceChar *)(argp8);
  my_kdata_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("kdata");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg10 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceBoolean mybool7 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, NAMELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("kinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, FILELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("kinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  arg6 = &temp6;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("kinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("kinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_kinfo_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("kinfo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ktotal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ktotal");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ktotal");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ktotal_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ktotal");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_kxtrct(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 = (SpiceChar *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  SpiceInt arg8 ;
  SpiceChar *arg9 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 = 0 ;
  int alloc5 = 0 ;
  SpiceBoolean mybool7 ;
  SpiceChar *buffer8 = NULL ;
  size_t dim18 ;
  int alloc8 = 0 ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim18 = max(1, MESSAGELEN);
    buffer8 = (SpiceChar *) PyMem_Malloc((dim18 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc8 = SWIG_NEWOBJ;
    
    buffer8[0] = '\0';   // String begins empty
    arg9 = buffer8;                                                // STRING
    arg8 = (SpiceInt)dim18;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "kxtrct", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("kxtrct");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("kxtrct");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("kxtrct");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("kxtrct");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  {
    //      (int DIM1, char *INOUT_STRING)
    //  TODO(FY): Add test for me
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&buffer5, &dim15, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // resize_char_array_to_minimum_size(&buffer5, &dim15, arg6_dim0, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt) dim15;                                        // DIM1
  }
  my_kxtrct_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("kxtrct");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer8[dim18-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer8);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc8)) {
      PyMem_Free((void *) buffer8);
    }
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc8)) {
      PyMem_Free((void *) buffer8);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgresp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble arg5 ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[4] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "lgresp", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lgresp" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lgresp" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("lgresp", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lgresp" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  result = my_lgresp_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgresp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgresp_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "lgresp_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("lgresp_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("lgresp_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("lgresp_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("lgresp_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  lgresp_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgresp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("lgresp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("lgresp_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lgresp_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgrind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg6 = &temp6;
  arg7 = &temp7;
  if (!SWIG_Python_UnpackTuple(args, "lgrind", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("lgrind", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("lgrind", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lgrind" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  my_lgrind_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgrind");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgrind_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "lgrind_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("lgrind_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("lgrind_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("lgrind_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  lgrind_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgrind_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("lgrind_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("lgrind_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lgrind_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("lgrind_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("lgrind_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lgrind_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgrint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble arg5 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "lgrint", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("lgrint", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("lgrint", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "lgrint" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  result = my_lgrint_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgrint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lgrint_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "lgrint_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("lgrint_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("lgrint_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("lgrint_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                          // ARRAY
    if (PyArray_NDIM(pyarr7) == 0) {
      arg8 = 0;                                                 // DIM1
    } else {
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
    }
  }
  lgrint_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lgrint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("lgrint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize9[0], 1);
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("lgrint_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9, dim * sizeof(SpiceDouble));
    if (dimsize9[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr9, PyArray_DATA(pyarr9));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lgrint_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr9 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
      // AppendOutput steals the reference to the argument.
      pyarr9 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lmpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  PyObject *list1 = NULL ;
  char *buffer1 = NULL ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *IN_STRINGS, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg1 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list1 = PySequence_List(swig_obj[0]);
      if (!list1) {
        handle_bad_sequence_to_list("lmpool");
        SWIG_fail;
      }
      
      // list1 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list1);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("lmpool");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("lmpool");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list1, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer1
      buffer1 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer1)) {
          handle_malloc_failure("lmpool");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer1 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg1 = (ConstSpiceChar *)buffer1;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  lmpool_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lmpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lparse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  char (*arg6)[NAMELEN] ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  char *buffer3 ;
  int dimsize3[2] ;
  PyObject *list3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize3[0] = MAXVALS;                                       // ARRAY_dim0
    dimsize3[1] = NAMELEN;                                       // NARRAY_dim1
    if (dimsize3[1] < 2) {
      dimsize3[1] = 2;
    }
    
    buffer3 = (char *) PyMem_Malloc(dimsize3[0] * dimsize3[1] * sizeof(char));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = buffer3;                                                // ARRAY
    arg3 = dimsize3[0];                                            // DIM1
    arg4 = dimsize3[1];                                            // DIM2
    arg5 = &dimsize3[0];                                           // NSTRINGS
  }
  if (!SWIG_Python_UnpackTuple(args, "lparse", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  lparse_c(arg1,arg2,arg3,arg4,arg5,(char (*)[NAMELEN])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list3 = PyList_New(dimsize3[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list3)) {
        handle_malloc_failure("lparse");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize3[0]; i++) {
      char *str = &buffer3[i * dimsize3[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lparse");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list3, i, value);
    }
    list3 = Py_BuildValue("[N]", list3);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list3);
    list3 = NULL;
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lparsm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  char (*arg6)[COLLEN] ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  SpiceChar *buffer3 ;
  int dimsize3[2] ;
  PyObject *list3 = NULL ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, int DIM2, int *NSTRINGS, char OUT_STRINGS[ANY][ANY])
    
    dimsize3[0] = MAXVALS;                                       // ARRAY_dim0
    dimsize3[1] = COLLEN;                                       // NARRAY_dim1
    if (dimsize3[1] < 2) {
      dimsize3[1] = 2;
    }
    
    buffer3 = (SpiceChar *) PyMem_Malloc(dimsize3[0] * dimsize3[1] * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = buffer3;                                                // ARRAY
    arg3 = dimsize3[0];                                            // DIM1
    arg4 = dimsize3[1];                                            // DIM2
    arg5 = &dimsize3[0];                                           // NSTRINGS
  }
  if (!SWIG_Python_UnpackTuple(args, "lparsm", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  lparsm_c(arg1,arg2,arg3,arg4,arg5,(char (*)[COLLEN])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list3 = PyList_New(dimsize3[0]);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list3)) {
        handle_malloc_failure("lparsm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < dimsize3[0]; i++) {
      char *str = &buffer3[i * dimsize3[1]];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("lparsm");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list3, i, value);
    }
    list3 = Py_BuildValue("[N]", list3);  // N steals the reference
    /*@SWIG@*/
    resultobj = SWIG_Python_AppendOutput(resultobj, list3);
    list3 = NULL;
  }
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return resultobj;
fail:
  {
    //      (char OUT_STRINGS[ANY][ANY], int DIM1, int DIM2, int *NSTRINGS)
    PyMem_Free((void *) buffer3);
    Py_XDECREF(list3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstlec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstlec", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lstlec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lstlec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("lstlec");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("lstlec");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("lstlec");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("lstlec");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  result = lstlec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstlec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstled", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lstled" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("lstled", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = lstled_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstled");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstlei(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstlei", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lstlei" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("lstlei", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = lstlei_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstlei");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstltc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstltc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lstltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lstltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("lstltc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("lstltc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("lstltc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("lstltc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  result = lstltc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstltc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstltd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstltd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lstltd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("lstltd", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = lstltd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstltd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lstlti(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceInt *arg3 = (ConstSpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "lstlti", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "lstlti" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (int DIM1, ConstSpiceInt *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("lstlti", NPY_INT, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceInt *) PyArray_DATA(pyarr2);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  result = lstlti_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lstlti");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_lx4dec(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "lx4dec", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lx4dec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lx4dec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lx4dec" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  lx4dec_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lx4dec");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lx4num(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "lx4num", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lx4num");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lx4num");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lx4num" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  lx4num_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lx4num");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lx4sgn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "lx4sgn", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lx4sgn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lx4sgn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lx4sgn" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  lx4sgn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lx4sgn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lx4uns(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "lx4uns", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lx4uns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lx4uns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lx4uns" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  lx4uns_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lx4uns");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_lxqstr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceChar arg2 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "lxqstr", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("lxqstr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lxqstr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("lxqstr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[1], &arg2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("lxqstr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "lxqstr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  lxqstr_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("lxqstr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    
  }
  return resultobj;
fail:
  {
    
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_matchi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceChar *arg2 = (SpiceChar *) 0 ;
  SpiceChar arg3 ;
  SpiceChar arg4 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "matchi", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[2], &arg3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[3], &arg4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  matchi_c(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    
  }
  {
    
  }
  {
    
  }
  {
    
  }
  return resultobj;
fail:
  {
    
  }
  {
    
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_matchw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceChar arg3 ;
  SpiceChar arg4 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "matchw", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[2], &arg3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[3], &arg4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("matchw");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  matchw_c(arg1,arg2,arg3,arg4);
  resultobj = SWIG_Py_Void();
  {
    
  }
  {
    
  }
  {
    
  }
  {
    
  }
  return resultobj;
fail:
  {
    
  }
  {
    
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_ncpos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "ncpos", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ncpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ncpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ncpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ncpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ncpos" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = ncpos_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ncpos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_ncposr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "ncposr", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("ncposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ncposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("ncposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("ncposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ncposr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = ncposr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("ncposr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_nextwd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  SpiceInt arg4 ;
  SpiceChar *arg5 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  SpiceChar *buffer4 = NULL ;
  size_t dim14 ;
  int alloc4 = 0 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, COLLEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("nextwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim14 = max(1, MESSAGELEN);
    buffer4 = (SpiceChar *) PyMem_Malloc((dim14 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer4)) {
        handle_malloc_failure("nextwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc4 = SWIG_NEWOBJ;
    
    buffer4[0] = '\0';   // String begins empty
    arg5 = buffer4;                                                // STRING
    arg4 = (SpiceInt)dim14;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("nextwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("nextwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  my_nextwd_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nextwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer4[dim14-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer4);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc4)) {
      PyMem_Free((void *) buffer4);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_nthwd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  SpiceChar *arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SpiceChar *buffer3 = NULL ;
  size_t dim13 ;
  int alloc3 = 0 ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim13 = max(1, COLLEN);
    buffer3 = (SpiceChar *) PyMem_Malloc((dim13 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer3)) {
        handle_malloc_failure("nthwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc3 = SWIG_NEWOBJ;
    
    buffer3[0] = '\0';   // String begins empty
    arg4 = buffer3;                                                // STRING
    arg3 = (SpiceInt)dim13;                                         // DIM1
  }
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "nthwd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("nthwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("nthwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nthwd" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  nthwd_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("nthwd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer3[dim13-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer3);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc3)) {
      PyMem_Free((void *) buffer3);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_orderc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt **arg5 = (SpiceInt **) 0 ;
  PyObject *list1 = NULL ;
  char *buffer1 = NULL ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "orderc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg3 = NULL;
      arg1 = 0;
      arg2 = 0;
      
      list1 = PySequence_List(swig_obj[0]);
      if (!list1) {
        handle_bad_sequence_to_list("orderc");
        SWIG_fail;
      }
      
      // list1 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list1);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("orderc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("orderc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list1, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer1
      buffer1 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer1)) {
          handle_malloc_failure("orderc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer1 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg3 = (ConstSpiceChar *)buffer1;
      arg1 = (int) count;
      arg2 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  res4 = SWIG_ConvertPtr(swig_obj[1], &argp4,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orderc" "', argument " "4"" of type '" "SpiceInt *""'"); 
  }
  arg4 = (SpiceInt *)(argp4);
  res5 = SWIG_ConvertPtr(swig_obj[2], &argp5,SWIGTYPE_p_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "orderc" "', argument " "5"" of type '" "SpiceInt **""'"); 
  }
  arg5 = (SpiceInt **)(argp5);
  my_orderc_c(arg1,arg2,arg3,arg4,arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("orderc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_orderd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt **arg4 = (SpiceInt **) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "orderd", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("orderd", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orderd" "', argument " "3"" of type '" "SpiceInt *""'"); 
  }
  arg3 = (SpiceInt *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orderd" "', argument " "4"" of type '" "SpiceInt **""'"); 
  }
  arg4 = (SpiceInt **)(argp4);
  my_orderd_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("orderd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_orderi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt **arg4 = (SpiceInt **) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "orderi", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceInt *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("orderi", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  res3 = SWIG_ConvertPtr(swig_obj[1], &argp3,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "orderi" "', argument " "3"" of type '" "SpiceInt *""'"); 
  }
  arg3 = (SpiceInt *)(argp3);
  res4 = SWIG_ConvertPtr(swig_obj[2], &argp4,SWIGTYPE_p_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "orderi" "', argument " "4"" of type '" "SpiceInt **""'"); 
  }
  arg4 = (SpiceInt **)(argp4);
  my_orderi_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("orderi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pckcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  pckcls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pcklof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pcklof");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pcklof");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  pcklof_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pcklof");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "pckopn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pckopn" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  pckopn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckuof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pckuof" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  pckuof_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckuof");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_pckw02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg7 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  SpiceDouble arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int alloc6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "pckw02", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "pckw02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pckw02" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("pckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pckw02" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pckw02" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("pckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "pckw02" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "pckw02" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "pckw02" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (SpiceDouble *IN_ARRAY1)
    //      (SpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("pckw02", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "pckw02" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  pckw02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pckw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltnrm(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceDouble *arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceDouble *arg4 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("pltnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "pltnrm", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltnrm", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnrm", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("pltnrm", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnrm", pyarr2, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("pltnrm", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (3))) {
        handle_invalid_array_shape_1d("pltnrm", pyarr3, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  pltnrm_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltnrm");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pltnrm_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
    arg12 = &dimsize10[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "pltnrm_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("pltnrm_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("pltnrm_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("pltnrm_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  pltnrm_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pltnrm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("pltnrm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize10[0], dimsize10[1]
    };
    if (dimsize10[0] == 0) {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr10 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("pltnrm_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10,
      PyArray_SIZE(pyarr10) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_polyds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  SpiceDouble arg4 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble *arg6 ;
  PyArrayObject *pyarr1 = NULL ;
  int val3 ;
  int ecode3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int size5[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      10
    };                               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("polyds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    arg5 = &size5[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "polyds", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("polyds", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_int(swig_obj[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "polyds" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_double(swig_obj[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "polyds" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  my_polyds_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("polyds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    // Reshape to indicate the number of elements we actually created
    npy_intp dims[1] = {
      size5[0]
    };
    PyArray_Dims shape = {
      dims, 1
    };
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_polyds_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceInt arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "polyds_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("polyds_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "polyds_vector" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("polyds_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                          // ARRAY
    if (PyArray_NDIM(pyarr5) == 0) {
      arg6 = 0;                                                 // DIM1
    } else {
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
    }
  }
  polyds_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  resultobj = SWIG_Py_Void();
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("polyds_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("polyds_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_pos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "pos", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("pos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("pos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("pos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pos" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = pos_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("pos");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_posr(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  PyObject *swig_obj[3] ;
  SpiceInt result;
  
  if (!SWIG_Python_UnpackTuple(args, "posr", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("posr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("posr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("posr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("posr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "posr" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  result = posr_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("posr");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_prompt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceChar *arg3 ;
  int alloc1 = 0 ;
  SpiceChar *buffer2 = NULL ;
  size_t dim12 ;
  int alloc2 = 0 ;
  PyObject *swig_obj[1] ;
  SpiceChar *result = 0 ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim12 = max(1, MESSAGELEN);
    buffer2 = (SpiceChar *) PyMem_Malloc((dim12 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer2)) {
        handle_malloc_failure("prompt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc2 = SWIG_NEWOBJ;
    
    buffer2[0] = '\0';   // String begins empty
    arg3 = buffer2;                                                // STRING
    arg2 = (SpiceInt)dim12;                                         // DIM1
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("prompt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("prompt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = (SpiceChar *)prompt_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("prompt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj,
      PyString_FromString((char *) result));
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer2[dim12-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer2);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return resultobj;
fail:
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc2)) {
      PyMem_Free((void *) buffer2);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_prsdp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  SpiceDouble temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("prsdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("prsdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  prsdp_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("prsdp");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_prsint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("prsint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("prsint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  prsint_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("prsint");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_qderiv(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  double val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  PyObject *swig_obj[5] ;
  
  if (!SWIG_Python_UnpackTuple(args, "qderiv", 5, 5, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("qderiv", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble *IN_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("qderiv", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode5 = SWIG_AsVal_double(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "qderiv" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "qderiv" "', argument " "6"" of type '" "SpiceInt *""'"); 
  }
  arg6 = (SpiceInt *)(argp6);
  res7 = SWIG_ConvertPtr(swig_obj[4], &argp7,SWIGTYPE_p_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "qderiv" "', argument " "7"" of type '" "SpiceDouble **""'"); 
  }
  arg7 = (SpiceDouble **)(argp7);
  my_qderiv_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("qderiv");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recazl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceBoolean arg2 ;
  SpiceBoolean arg3 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "recazl", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recazl", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("recazl", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "recazl" "', argument " "2"" of type '" "SpiceBoolean""'");
  } 
  arg2 = (SpiceBoolean)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "recazl" "', argument " "3"" of type '" "SpiceBoolean""'");
  } 
  arg3 = (SpiceBoolean)(val3);
  recazl_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recazl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_recazl_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  SpiceDouble **arg8 = (SpiceDouble **) 0 ;
  int *arg9 = (int *) 0 ;
  SpiceDouble **arg10 = (SpiceDouble **) 0 ;
  int *arg11 = (int *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr6 = NULL ;
  PyArrayObject *pyarr8 = NULL ;
  SpiceDouble *buffer8 = NULL ;
  int dimsize8[1] ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble *buffer10 = NULL ;
  int dimsize10[1] ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[1] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg8 = &buffer8;                                               // ARRAY
    arg9 = &dimsize8[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg10 = &buffer10;                                               // ARRAY
    arg11 = &dimsize10[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "recazl_vector", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("recazl_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("recazl_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("recazl_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  recazl_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer8)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize8[0], 1);
    pyarr8 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr8)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr8), buffer8, dim * sizeof(SpiceDouble));
    if (dimsize8[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr8, PyArray_DATA(pyarr8));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recazl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr8 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr8);
      // AppendOutput steals the reference to the argument.
      pyarr8 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer10)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize10[0], 1);
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr10), buffer10, dim * sizeof(SpiceDouble));
    if (dimsize10[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr10, PyArray_DATA(pyarr10));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recazl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr10 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr10);
      // AppendOutput steals the reference to the argument.
      pyarr10 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize12[0], 1);
    pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("recazl_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12, dim * sizeof(SpiceDouble));
    if (dimsize12[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr12, PyArray_DATA(pyarr12));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("recazl_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr12 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr12);
      // AppendOutput steals the reference to the argument.
      pyarr12 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr8);
    PyMem_Free((void *) buffer8);
  }
  {
    Py_XDECREF(pyarr10);
    PyMem_Free((void *) buffer10);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reordc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  char *arg4 = (char *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reordc", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reordc", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
  }
  {
    //      (int DIM1, int DIM2, char *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("reordc");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("reordc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("reordc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(char));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("reordc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (char *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  reordc_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reordc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (int DIM1, int DIM2, char *INOUT_STRINGS)
    // We can reuse list2, but first we need to free whatever is already there.
    Py_XDECREF(list2);
    list2 = NULL;
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list2 = PyList_New(arg2);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list2)) {
        handle_malloc_failure("reordc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < arg2; i++) {
      char *str = &buffer2[i * arg3];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("reordc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list2, i, value);
    }
    list2 = Py_BuildValue("[N]", list2);  // N steals the reference
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, list2);
    list2 = NULL;
  }
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reordd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reordd", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reordd", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reordd" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "reordd" "', argument " "3"" of type '" "SpiceDouble *""'"); 
  }
  arg3 = (SpiceDouble *)(argp3);
  reordd_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reordd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reordi(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reordi", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reordi", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reordi" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "reordi" "', argument " "3"" of type '" "SpiceInt *""'"); 
  }
  arg3 = (SpiceInt *)(argp3);
  reordi_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reordi");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_reordl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  PyObject *swig_obj[3] ;
  
  if (!SWIG_Python_UnpackTuple(args, "reordl", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceInt *IN_ARRAY1)
    //      (ConstSpiceInt IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("reordl", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "reordl" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  res3 = SWIG_ConvertPtr(swig_obj[2], &argp3,SWIGTYPE_p_SpiceBoolean, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "reordl" "', argument " "3"" of type '" "SpiceBoolean *""'"); 
  }
  arg3 = (SpiceBoolean *)(argp3);
  reordl_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("reordl");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_repml(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  SpiceBoolean arg3 ;
  SpiceChar arg4 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceChar *buffer5 = NULL ;
  size_t dim15 ;
  int alloc5 = 0 ;
  PyObject *swig_obj[4] ;
  
  {
    //      (int DIM1, char OUT_STRING[ANY])
    
    dim15 = max(1, MESSAGELEN);
    buffer5 = (SpiceChar *) PyMem_Malloc((dim15 + 1) * sizeof(SpiceChar));
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("repml");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    alloc5 = SWIG_NEWOBJ;
    
    buffer5[0] = '\0';   // String begins empty
    arg6 = buffer5;                                                // STRING
    arg5 = (SpiceInt)dim15;                                         // DIM1
  }
  if (!SWIG_Python_UnpackTuple(args, "repml", 4, 4, swig_obj)) SWIG_fail;
  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "repml" "', argument " "1"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg1 = (ConstSpiceDouble *)(argp1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ConstSpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "repml" "', argument " "2"" of type '" "ConstSpiceDouble *""'"); 
  }
  arg2 = (ConstSpiceDouble *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "repml" "', argument " "3"" of type '" "SpiceBoolean""'");
  } 
  arg3 = (SpiceBoolean)(val3);
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("repml");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[3], &arg4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("repml");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  repml_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("repml");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    buffer5[dim15-1] = '\0';  // Make sure string is terminated
    PyObject *obj = PyString_FromString((SpiceChar *) buffer5);
    resultobj = SWIG_Python_AppendOutput(resultobj, obj);
  }
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return resultobj;
fail:
  {
    
  }
  {
    //      (... SpiceChar INOUT_STRING[ANY] ...)
    //      (... SpiceChar *INOUT_STRING ...)
    //      (... SpiceChar OUT_STRING[ANY] ...)
    
    if (SWIG_IsNewObj(alloc5)) {
      PyMem_Free((void *) buffer5);
    }
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_return_(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "return_", 0, 0, 0)) SWIG_fail;
  result = return_c();
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("return_");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shellc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  char *arg3 = (char *) 0 ;
  PyObject *list1 = NULL ;
  char *buffer1 = NULL ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (int DIM1, int DIM2, char *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg3 = NULL;
      arg1 = 0;
      arg2 = 0;
      
      list1 = PySequence_List(swig_obj[0]);
      if (!list1) {
        handle_bad_sequence_to_list("shellc");
        SWIG_fail;
      }
      
      // list1 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list1);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("shellc");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("shellc");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list1, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer1
      buffer1 = PyMem_Malloc(count * (maxlen + 1) * sizeof(char));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer1)) {
          handle_malloc_failure("shellc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list1, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer1 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg3 = (char *)buffer1;
      arg1 = (int) count;
      arg2 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  shellc_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("shellc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    //      (int DIM1, int DIM2, char *INOUT_STRINGS)
    // We can reuse list1, but first we need to free whatever is already there.
    Py_XDECREF(list1);
    list1 = NULL;
    /*@SWIG:swig/cspyce_typemaps.i,679,CONVERT_BUFFER_TO_ARRAY_OF_STRINGS@*/
    list1 = PyList_New(arg1);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(list1)) {
        handle_malloc_failure("shellc");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    // Convert the results to Python strings and add them to the list
    for (int i = 0; i < arg1; i++) {
      char *str = &buffer1[i * arg2];
      PyObject *value = PyString_FromString(str);
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("shellc");
          SWIG_fail;
        }
      }
      /*@SWIG@*/
      PyList_SetItem(list1, i, value);
    }
    list1 = Py_BuildValue("[N]", list1);  // N steals the reference
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, list1);
    list1 = NULL;
  }
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list1);
    PyMem_Free((void *) buffer1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_shelld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble *arg2 = (SpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "shelld", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "shelld" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpiceDouble, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shelld" "', argument " "2"" of type '" "SpiceDouble *""'"); 
  }
  arg2 = (SpiceDouble *)(argp2);
  shelld_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("shelld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_shelli(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "shelli", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "shelli" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shelli" "', argument " "2"" of type '" "SpiceInt *""'"); 
  }
  arg2 = (SpiceInt *)(argp2);
  shelli_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("shelli");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spk14a(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[4] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spk14a", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spk14a" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spk14a" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("spk14a", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("spk14a", NPY_DOUBLE, swig_obj[3], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
  }
  spk14a_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spk14a");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spk14b(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  SpiceInt arg8 ;
  int val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  PyObject *swig_obj[8] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spk14b", 8, 8, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spk14b" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("spk14b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spk14b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spk14b" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spk14b" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spk14b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spk14b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spk14b" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "spk14b" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spk14b" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  spk14b_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spk14b");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spk14e(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spk14e" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  spk14e_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spk14e");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcls(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkcls" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  spkcls_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcls");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcpo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg9 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  if (!SWIG_Python_UnpackTuple(args, "spkcpo", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkcpo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkcpo", NPY_DOUBLE, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr6) && (PyArray_DIM(pyarr6, 0) != (3))) {
        handle_invalid_array_shape_1d("spkcpo", pyarr6, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcpo_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcpo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcpo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  ConstSpiceChar *arg10 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg11 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  SpiceDouble **arg15 = (SpiceDouble **) 0 ;
  int *arg16 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  int alloc10 = 0 ;
  int alloc11 = 0 ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyArrayObject *pyarr15 = NULL ;
  SpiceDouble *buffer15 = NULL ;
  int dimsize15[1] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg15 = &buffer15;                                               // ARRAY
    arg16 = &dimsize15[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkcpo_vector", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkcpo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("spkcpo_vector", NPY_DOUBLE, swig_obj[5], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg10, NULL, &alloc10);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg11, NULL, &alloc11);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcpo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize15[0], 1);
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("spkcpo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr15), buffer15, dim * sizeof(SpiceDouble));
    if (dimsize15[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr15, PyArray_DATA(pyarr15));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkcpo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr15 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
      // AppendOutput steals the reference to the argument.
      pyarr15 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg9 ;
  SpiceDouble *arg10 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble temp10 ;
  int res10 = SWIG_TMPOBJ ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr9 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (SpiceDouble *) PyArray_DATA(pyarr9);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg10 = &temp10;
  if (!SWIG_Python_UnpackTuple(args, "spkcpt", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("spkcpt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (3))) {
        handle_invalid_array_shape_1d("spkcpt", pyarr1, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spkcpt" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr9);
    // AppendOutput steals the reference to the argument.
    pyarr9 = NULL;
  }
  if (SWIG_IsTmpObj(res10)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg10)));
  } else {
    int new_flags = SWIG_IsNewObj(res10) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg10), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 = (ConstSpiceDouble *) 0 ;
  int arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg10 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg11 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg12 = (SpiceDouble **) 0 ;
  int *arg13 = (int *) 0 ;
  int *arg14 = (int *) 0 ;
  SpiceDouble **arg15 = (SpiceDouble **) 0 ;
  int *arg16 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  int alloc10 = 0 ;
  int alloc11 = 0 ;
  PyArrayObject *pyarr12 = NULL ;
  SpiceDouble *buffer12 = NULL ;
  int dimsize12[2] ;
  PyArrayObject *pyarr15 = NULL ;
  SpiceDouble *buffer15 = NULL ;
  int dimsize15[1] ;
  PyObject *swig_obj[8] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg12 = &buffer12;                                               // ARRAY
    arg13 = &dimsize12[0];                                           // SIZE1
    arg14 = &dimsize12[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg15 = &buffer15;                                               // ARRAY
    arg16 = &dimsize15[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkcpt_vector", 8, 8, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("spkcpt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[3], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkcpt_vector", NPY_DOUBLE, swig_obj[3], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    if (PyArray_NDIM(pyarr6) == 0) {
      arg7 = 0;                                                 // DIM1
    } else {
      arg7 = (int) PyArray_DIM(pyarr6, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg10, NULL, &alloc10);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg11, NULL, &alloc11);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer12)) {
        handle_malloc_failure("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize12[0], dimsize12[1]
    };
    if (dimsize12[0] == 0) {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr12 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr12)) {
        handle_malloc_failure("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr12), buffer12,
      PyArray_SIZE(pyarr12) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr12);
    // AppendOutput steals the reference to the argument.
    pyarr12 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer15)) {
        handle_malloc_failure("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize15[0], 1);
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("spkcpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr15), buffer15, dim * sizeof(SpiceDouble));
    if (dimsize15[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr15, PyArray_DATA(pyarr15));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkcpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr15 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr15);
      // AppendOutput steals the reference to the argument.
      pyarr15 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr12);
    PyMem_Free((void *) buffer12);
  }
  {
    Py_XDECREF(pyarr15);
    PyMem_Free((void *) buffer15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcvo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg6 ;
  SpiceDouble arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  int alloc1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  PyArrayObject *pyarr6 = NULL ;
  double val7 ;
  int ecode7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  if (!SWIG_Python_UnpackTuple(args, "spkcvo", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkcvo" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr6 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr6){
        handle_bad_array_conversion("spkcvo", NPY_DOUBLE, swig_obj[5], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr6) && (PyArray_DIM(pyarr6, 0) != (6))) {
        handle_invalid_array_shape_1d("spkcvo", pyarr6, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg6 = (ConstSpiceDouble *) PyArray_DATA(pyarr6);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr6, 0);                            // DIM1
  }
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "spkcvo" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcvo_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcvo");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr6);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcvo_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg2 = (ConstSpiceDouble *) 0 ;
  int arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg7 = (ConstSpiceDouble *) 0 ;
  int arg8 ;
  int arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  ConstSpiceChar *arg12 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg13 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  int alloc1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  int alloc12 = 0 ;
  int alloc13 = 0 ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[2] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[1] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
    arg16 = &dimsize14[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkcvo_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkcvo_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    if (PyArray_NDIM(pyarr2) == 0) {
      arg3 = 0;                                                 // DIM1
    } else {
      arg3 = (int) PyArray_DIM(pyarr2, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr7 = PyArray_FROMANY(swig_obj[5], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr7){
        handle_bad_array_conversion("spkcvo_vector", NPY_DOUBLE, swig_obj[5], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr7) == 1) {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = 0;                                                 // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 0);                        // DIM2
    } else {
      arg7 = (ConstSpiceDouble *) PyArray_DATA(pyarr7);                    // ARRAY
      arg8 = (int) PyArray_DIM(pyarr7, 0);                        // DIM1
      arg9 = (int) PyArray_DIM(pyarr7, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[6], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkcvo_vector", NPY_DOUBLE, swig_obj[6], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    if (PyArray_NDIM(pyarr10) == 0) {
      arg11 = 0;                                                 // DIM1
    } else {
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg12, NULL, &alloc12);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg13, NULL, &alloc13);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcvo_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize14[0], dimsize14[1]
    };
    if (dimsize14[0] == 0) {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14,
      PyArray_SIZE(pyarr14) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize17[0], 1);
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("spkcvo_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17, dim * sizeof(SpiceDouble));
    if (dimsize17[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr17, PyArray_DATA(pyarr17));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkcvo_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr17 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr17);
      // AppendOutput steals the reference to the argument.
      pyarr17 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr7);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcvt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceDouble arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  double val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  if (!SWIG_Python_UnpackTuple(args, "spkcvt", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("spkcvt", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("spkcvt", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkcvt" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkcvt" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcvt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcvt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkcvt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 = (ConstSpiceDouble *) 0 ;
  int arg9 ;
  ConstSpiceChar *arg10 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg11 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg12 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg13 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg14 = (SpiceDouble **) 0 ;
  int *arg15 = (int *) 0 ;
  int *arg16 = (int *) 0 ;
  SpiceDouble **arg17 = (SpiceDouble **) 0 ;
  int *arg18 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  int alloc10 = 0 ;
  int alloc11 = 0 ;
  int alloc12 = 0 ;
  int alloc13 = 0 ;
  PyArrayObject *pyarr14 = NULL ;
  SpiceDouble *buffer14 = NULL ;
  int dimsize14[2] ;
  PyArrayObject *pyarr17 = NULL ;
  SpiceDouble *buffer17 = NULL ;
  int dimsize17[1] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg14 = &buffer14;                                               // ARRAY
    arg15 = &dimsize14[0];                                           // SIZE1
    arg16 = &dimsize14[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg17 = &buffer17;                                               // ARRAY
    arg18 = &dimsize17[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkcvt_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("spkcvt_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("spkcvt_vector", NPY_DOUBLE, swig_obj[1], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                          // ARRAY
    if (PyArray_NDIM(pyarr4) == 0) {
      arg5 = 0;                                                 // DIM1
    } else {
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[4], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("spkcvt_vector", NPY_DOUBLE, swig_obj[4], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    if (PyArray_NDIM(pyarr8) == 0) {
      arg9 = 0;                                                 // DIM1
    } else {
      arg9 = (int) PyArray_DIM(pyarr8, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg10, NULL, &alloc10);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg11, NULL, &alloc11);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg12, NULL, &alloc12);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg13, NULL, &alloc13);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkcvt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer14)) {
        handle_malloc_failure("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize14[0], dimsize14[1]
    };
    if (dimsize14[0] == 0) {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr14 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr14)) {
        handle_malloc_failure("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr14), buffer14,
      PyArray_SIZE(pyarr14) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr14);
    // AppendOutput steals the reference to the argument.
    pyarr14 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer17)) {
        handle_malloc_failure("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize17[0], 1);
    pyarr17 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr17)) {
        handle_malloc_failure("spkcvt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr17), buffer17, dim * sizeof(SpiceDouble));
    if (dimsize17[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr17, PyArray_DATA(pyarr17));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("spkcvt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr17 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr17);
      // AppendOutput steals the reference to the argument.
      pyarr17 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr4);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    Py_XDECREF(pyarr14);
    PyMem_Free((void *) buffer14);
  }
  {
    Py_XDECREF(pyarr17);
    PyMem_Free((void *) buffer17);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spklef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spklef_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spklef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkopa(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkopa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkopa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  spkopa_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkopa");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkopn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  if (!SWIG_Python_UnpackTuple(args, "spkopn", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("spkopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("spkopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkopn" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  spkopn_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkopn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkpds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  SpiceDouble *arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  PyArrayObject *pyarr7 = NULL ;
  PyObject *swig_obj[6] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      5
    };                               // DIMENSIONS
    pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("spkpds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg7 = (SpiceDouble *) PyArray_DATA(pyarr7);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr7, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "spkpds", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkpds" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkpds" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spkpds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkpds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spkpds" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkpds" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkpds" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  spkpds_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkpds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    Py_XDECREF(pyarr7);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkpvn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceDouble *arg2 ;
  SpiceDouble arg3 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceDouble *arg5 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  double val3 ;
  int ecode3 = 0 ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  PyObject *swig_obj[3] ;
  
  arg4 = &temp4;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      6
    };                               // DIMENSIONS
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("spkpvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (SpiceDouble *) PyArray_DATA(pyarr5);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg6 = &temp6;
  if (!SWIG_Python_UnpackTuple(args, "spkpvn", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkpvn" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spkpvn", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("spkpvn", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkpvn" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  spkpvn_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkpvn");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spksfs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble arg2 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceDouble *arg4 ;
  SpiceInt arg5 ;
  SpiceChar *arg6 = (SpiceChar *) 0 ;
  SpiceBoolean *arg7 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr4 = NULL ;
  int val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SpiceInt mybool7 ;
  PyObject *swig_obj[4] ;
  
  arg3 = &temp3;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      5
    };                               // DIMENSIONS
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("spksfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble *) PyArray_DATA(pyarr4);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  {
    //      (SpiceInt *OUT_BOOLEAN)
    
    arg7 = &mybool7;
  }
  if (!SWIG_Python_UnpackTuple(args, "spksfs", 4, 4, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spksfs" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spksfs" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  ecode5 = SWIG_AsVal_int(swig_obj[2], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spksfs" "', argument " "5"" of type '" "SpiceInt""'");
  } 
  arg5 = (SpiceInt)(val5);
  res6 = SWIG_ConvertPtr(swig_obj[3], &argp6,SWIGTYPE_p_SpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "spksfs" "', argument " "6"" of type '" "SpiceChar *""'"); 
  }
  arg6 = (SpiceChar *)(argp6);
  my_spksfs_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spksfs");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceInt *OUT_BOOLEAN)
    
    long test = (*arg7 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spksub(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble *arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg4 ;
  SpiceDouble arg5 ;
  SpiceInt arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  int alloc3 = 0 ;
  double val4 ;
  int ecode4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  PyObject *swig_obj[6] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spksub", 6, 6, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spksub" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  {
    //      (SpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("spksub", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 0) != (5))) {
        handle_invalid_array_shape_1d("spksub", pyarr2, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (SpiceDouble *) PyArray_DATA(pyarr2);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                            // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("spksub");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spksub");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spksub" "', argument " "4"" of type '" "SpiceDouble""'");
  } 
  arg4 = (SpiceDouble)(val4);
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spksub" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_int(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spksub" "', argument " "6"" of type '" "SpiceInt""'");
  } 
  arg6 = (SpiceInt)(val6);
  spksub_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spksub");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkuds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceInt *arg4 = (SpiceInt *) 0 ;
  SpiceInt *arg5 = (SpiceInt *) 0 ;
  SpiceDouble *arg6 = (SpiceDouble *) 0 ;
  SpiceDouble *arg7 = (SpiceDouble *) 0 ;
  SpiceInt *arg8 = (SpiceInt *) 0 ;
  SpiceInt *arg9 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceInt temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceInt temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceDouble temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceDouble temp7 ;
  int res7 = SWIG_TMPOBJ ;
  SpiceInt temp8 ;
  int res8 = SWIG_TMPOBJ ;
  SpiceInt temp9 ;
  int res9 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  arg8 = &temp8;
  arg9 = &temp9;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("spkuds", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (5))) {
        handle_invalid_array_shape_1d("spkuds", pyarr1, 5);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  spkuds_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkuds");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res8)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
  } else {
    int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res9)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg9)));
  } else {
    int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkuef(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkuef" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  spkuef_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkuef");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw02(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceInt arg9 ;
  SpiceInt arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw02", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw02" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw02" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw02" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw02" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw02" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw02" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw02" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "spkw02" "', argument " "10"" of type '" "SpiceInt""'");
  } 
  arg10 = (SpiceInt)(val10);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw02", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw02" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  spkw02_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw02");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw03(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceInt arg9 ;
  SpiceInt arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw03", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw03" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw03" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw03" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw03" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw03" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw03" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw03" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "spkw03" "', argument " "10"" of type '" "SpiceInt""'");
  } 
  arg10 = (SpiceInt)(val10);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw03", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw03" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  spkw03_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw03");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw05(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw05", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw05" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw05" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw05" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw05" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw05" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw05" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw05" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw05", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw05", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  spkw05_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw05");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw08(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw08", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw08" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw08" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw08" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw08");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw08");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw08" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw08" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw08");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw08");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw08" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw08" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw08", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "spkw08" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw08" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  spkw08_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw08");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw09(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw09", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw09" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw09" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw09" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw09");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw09");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw09" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw09" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw09");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw09");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw09" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw09" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw09", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw09", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  spkw09_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw09");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw10(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  PyArrayObject *pyarr8 = NULL ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw10", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw10" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw10" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw10" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw10");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw10");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw10" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw10" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw10");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw10");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr8 = PyArray_FROMANY(swig_obj[7], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr8){
        handle_bad_array_conversion("spkw10", NPY_DOUBLE, swig_obj[7], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr8) && (PyArray_DIM(pyarr8, 0) != (8))) {
        handle_invalid_array_shape_1d("spkw10", pyarr8, 8);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg8 = (ConstSpiceDouble *) PyArray_DATA(pyarr8);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr8, 0);                            // DIM1
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw10" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw10", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw10", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  spkw10_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw10");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr8);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw12(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw12", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw12" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw12" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw12" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw12");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw12");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw12" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw12" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw12");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw12");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw12" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw12" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw12", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "spkw12" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw12" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  spkw12_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw12");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw13(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceInt arg8 ;
  SpiceInt arg9 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr11 = NULL ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw13", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw13" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw13" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw13" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw13");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw13");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw13" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw13" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw13");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw13");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_int(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw13" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw13" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw13", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw13", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  spkw13_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw13");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw15(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  ConstSpiceDouble *arg9 ;
  ConstSpiceDouble *arg10 ;
  SpiceDouble arg11 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  ConstSpiceDouble *arg14 ;
  SpiceDouble arg15 ;
  SpiceDouble arg16 ;
  SpiceDouble arg17 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  double val11 ;
  int ecode11 = 0 ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  PyArrayObject *pyarr14 = NULL ;
  double val15 ;
  int ecode15 = 0 ;
  double val16 ;
  int ecode16 = 0 ;
  double val17 ;
  int ecode17 = 0 ;
  PyObject *swig_obj[17] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw15", 17, 17, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw15" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw15" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw15" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw15");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw15");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw15" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw15" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw15");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw15");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw15" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("spkw15", NPY_DOUBLE, swig_obj[8], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr9) && (PyArray_DIM(pyarr9, 0) != (3))) {
        handle_invalid_array_shape_1d("spkw15", pyarr9, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[9], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("spkw15", NPY_DOUBLE, swig_obj[9], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr10) && (PyArray_DIM(pyarr10, 0) != (3))) {
        handle_invalid_array_shape_1d("spkw15", pyarr10, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
  }
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "spkw15" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw15" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "spkw15" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr14 = PyArray_FROMANY(swig_obj[13], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr14){
        handle_bad_array_conversion("spkw15", NPY_DOUBLE, swig_obj[13], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr14) && (PyArray_DIM(pyarr14, 0) != (3))) {
        handle_invalid_array_shape_1d("spkw15", pyarr14, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg14 = (ConstSpiceDouble *) PyArray_DATA(pyarr14);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr14, 0);                            // DIM1
  }
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "spkw15" "', argument " "15"" of type '" "SpiceDouble""'");
  } 
  arg15 = (SpiceDouble)(val15);
  ecode16 = SWIG_AsVal_double(swig_obj[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), "in method '" "spkw15" "', argument " "16"" of type '" "SpiceDouble""'");
  } 
  arg16 = (SpiceDouble)(val16);
  ecode17 = SWIG_AsVal_double(swig_obj[16], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), "in method '" "spkw15" "', argument " "17"" of type '" "SpiceDouble""'");
  } 
  arg17 = (SpiceDouble)(val17);
  spkw15_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw15");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr14);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr10);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr14);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw17(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  ConstSpiceDouble *arg9 ;
  SpiceDouble arg10 ;
  SpiceDouble arg11 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  double val10 ;
  int ecode10 = 0 ;
  double val11 ;
  int ecode11 = 0 ;
  PyObject *swig_obj[11] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw17", 11, 11, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw17" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw17" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw17" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw17");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw17");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw17" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw17" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw17");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw17");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw17" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("spkw17", NPY_DOUBLE, swig_obj[8], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr9) && (PyArray_DIM(pyarr9, 0) != (9))) {
        handle_invalid_array_shape_1d("spkw17", pyarr9, 9);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
  }
  ecode10 = SWIG_AsVal_double(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "spkw17" "', argument " "10"" of type '" "SpiceDouble""'");
  } 
  arg10 = (SpiceDouble)(val10);
  ecode11 = SWIG_AsVal_double(swig_obj[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), "in method '" "spkw17" "', argument " "11"" of type '" "SpiceDouble""'");
  } 
  arg11 = (SpiceDouble)(val11);
  spkw17_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw17");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw18(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceInt arg3 ;
  SpiceInt arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg6 ;
  SpiceDouble arg7 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  SpiceInt arg9 ;
  SpiceInt arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  ConstSpiceDouble *arg12 = (ConstSpiceDouble *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int alloc5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  double val7 ;
  int ecode7 = 0 ;
  int alloc8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  PyArrayObject *pyarr12 = NULL ;
  PyObject *swig_obj[12] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw18", 12, 12, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw18" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ConstSpiceChar, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "spkw18" "', argument " "2"" of type '" "ConstSpiceChar *""'"); 
  }
  arg2 = (ConstSpiceChar *)(argp2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw18" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "spkw18" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("spkw18");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw18");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw18" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  ecode7 = SWIG_AsVal_double(swig_obj[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "spkw18" "', argument " "7"" of type '" "SpiceDouble""'");
  } 
  arg7 = (SpiceDouble)(val7);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("spkw18");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw18");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw18" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "spkw18" "', argument " "10"" of type '" "SpiceInt""'");
  } 
  arg10 = (SpiceInt)(val10);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw18", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr12 = PyArray_FROMANY(swig_obj[11], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr12){
        handle_bad_array_conversion("spkw18", NPY_DOUBLE, swig_obj[11], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg12 = (ConstSpiceDouble *) PyArray_DATA(pyarr12);                          // ARRAY
  }
  my_spkw18_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw18");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr12);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr12);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_spkw20(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg5 ;
  SpiceDouble arg6 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg8 ;
  SpiceInt arg9 ;
  SpiceInt arg10 ;
  ConstSpiceDouble *arg11 = (ConstSpiceDouble *) 0 ;
  SpiceDouble arg12 ;
  SpiceDouble arg13 ;
  SpiceDouble arg14 ;
  SpiceDouble arg15 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  double val5 ;
  int ecode5 = 0 ;
  double val6 ;
  int ecode6 = 0 ;
  int alloc7 = 0 ;
  double val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  double val12 ;
  int ecode12 = 0 ;
  double val13 ;
  int ecode13 = 0 ;
  double val14 ;
  int ecode14 = 0 ;
  double val15 ;
  int ecode15 = 0 ;
  PyObject *swig_obj[15] ;
  
  if (!SWIG_Python_UnpackTuple(args, "spkw20", 15, 15, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "spkw20" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "spkw20" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "spkw20" "', argument " "3"" of type '" "SpiceInt""'");
  } 
  arg3 = (SpiceInt)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("spkw20");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw20");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode5 = SWIG_AsVal_double(swig_obj[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "spkw20" "', argument " "5"" of type '" "SpiceDouble""'");
  } 
  arg5 = (SpiceDouble)(val5);
  ecode6 = SWIG_AsVal_double(swig_obj[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "spkw20" "', argument " "6"" of type '" "SpiceDouble""'");
  } 
  arg6 = (SpiceDouble)(val6);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("spkw20");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("spkw20");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode8 = SWIG_AsVal_double(swig_obj[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "spkw20" "', argument " "8"" of type '" "SpiceDouble""'");
  } 
  arg8 = (SpiceDouble)(val8);
  ecode9 = SWIG_AsVal_int(swig_obj[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "spkw20" "', argument " "9"" of type '" "SpiceInt""'");
  } 
  arg9 = (SpiceInt)(val9);
  ecode10 = SWIG_AsVal_int(swig_obj[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), "in method '" "spkw20" "', argument " "10"" of type '" "SpiceInt""'");
  } 
  arg10 = (SpiceInt)(val10);
  {
    //      (ConstSpiceDouble *IN_ARRAY1)
    //      (ConstSpiceDouble IN_ARRAY1[]
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr11 = PyArray_FROMANY(swig_obj[10], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr11){
        handle_bad_array_conversion("spkw20", NPY_DOUBLE, swig_obj[10], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg11 = (ConstSpiceDouble *) PyArray_DATA(pyarr11);                          // ARRAY
  }
  ecode12 = SWIG_AsVal_double(swig_obj[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), "in method '" "spkw20" "', argument " "12"" of type '" "SpiceDouble""'");
  } 
  arg12 = (SpiceDouble)(val12);
  ecode13 = SWIG_AsVal_double(swig_obj[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), "in method '" "spkw20" "', argument " "13"" of type '" "SpiceDouble""'");
  } 
  arg13 = (SpiceDouble)(val13);
  ecode14 = SWIG_AsVal_double(swig_obj[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), "in method '" "spkw20" "', argument " "14"" of type '" "SpiceDouble""'");
  } 
  arg14 = (SpiceDouble)(val14);
  ecode15 = SWIG_AsVal_double(swig_obj[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), "in method '" "spkw20" "', argument " "15"" of type '" "SpiceDouble""'");
  } 
  arg15 = (SpiceDouble)(val15);
  spkw20_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("spkw20");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sumad(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceDouble result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("sumad", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = sumad_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sumad");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_sumai(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceInt *arg1 = (ConstSpiceInt *) 0 ;
  SpiceInt arg2 ;
  PyArrayObject *pyarr1 = NULL ;
  PyObject *swig_obj[1] ;
  SpiceInt result;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceInt *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_INT, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("sumai", NPY_INT, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceInt *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  result = sumai_c(arg1,arg2);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("sumai");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyInt_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceInt ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_swpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt arg2 ;
  SpiceInt arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *list2 = NULL ;
  char *buffer2 = NULL ;
  PyObject *swig_obj[2] ;
  
  if (!SWIG_Python_UnpackTuple(args, "swpool", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("swpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("swpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, int DIM2, ConstSpiceChar *IN[OUT]_STRINGS)
    
    /*@SWIG:swig/cspyce_typemaps.i,737,HANDLE_TYPEMAP_IN_STRINGS@*/
    {
      arg4 = NULL;
      arg2 = 0;
      arg3 = 0;
      
      list2 = PySequence_List(swig_obj[1]);
      if (!list2) {
        handle_bad_sequence_to_list("swpool");
        SWIG_fail;
      }
      
      // list2 is guaranteed to be a PyList, and we own it.
      Py_ssize_t count = PyList_Size(list2);
      Py_ssize_t maxlen = 2;
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);  // Note, we don't own this object
        /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
        {
          if (is_python_3xx ? !PyUnicode_Check(obj) : !PyString_Check(obj)) {
            handle_bad_string_error("swpool");
            SWIG_fail;
          }
        }
        /*@SWIG@*/;
        if (is_python_3xx) {
          obj = PyUnicode_AsUTF8String(obj);   // We own this item
          /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
          {
            if (!(obj)) {
              handle_malloc_failure("swpool");
              SWIG_fail;
            }
          }
          /*@SWIG@*/;
          PyList_SetItem(list2, i, obj);        // And SetItem steals the ownership
        }
        maxlen = max(maxlen, PyBytes_Size(obj));
      }
      // Allocate the buffer2
      buffer2 = PyMem_Malloc(count * (maxlen + 1) * sizeof(ConstSpiceChar));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(buffer2)) {
          handle_malloc_failure("swpool");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // Copy the strings
      for (int i = 0; i < count; i++) {
        PyObject *obj = PyList_GetItem(list2, i);
        // PyBytes_AsString simply grabs a pointer out of the python object.
        strncpy((buffer2 + i * (maxlen+1)), PyBytes_AsString(obj), maxlen+1);
      }
      arg4 = (ConstSpiceChar *)buffer2;
      arg2 = (int) count;
      arg3 = (int)(maxlen + 1);
    }
    /*@SWIG@*/
  }
  swpool_c(arg1,arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("swpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(list2);
    PyMem_Free((void *) buffer2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_szpool(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  SpiceInt *arg2 = (SpiceInt *) 0 ;
  SpiceBoolean *arg3 = (SpiceBoolean *) 0 ;
  int alloc1 = 0 ;
  SpiceInt temp2 ;
  int res2 = SWIG_TMPOBJ ;
  SpiceBoolean mybool3 ;
  PyObject *swig_obj[1] ;
  
  arg2 = &temp2;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg3 = &mybool3;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("szpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("szpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  szpool_c(arg1,arg2,arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("szpool");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  if (SWIG_IsTmpObj(res2)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
  } else {
    int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg3 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_tangpt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  SpiceDouble arg3 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg9 ;
  SpiceDouble *arg10 ;
  SpiceDouble *arg11 = (SpiceDouble *) 0 ;
  SpiceDouble *arg12 = (SpiceDouble *) 0 ;
  SpiceDouble *arg13 ;
  SpiceDouble *arg14 = (SpiceDouble *) 0 ;
  SpiceDouble *arg15 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  double val3 ;
  int ecode3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  PyArrayObject *pyarr10 = NULL ;
  SpiceDouble temp11 ;
  int res11 = SWIG_TMPOBJ ;
  SpiceDouble temp12 ;
  int res12 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble temp14 ;
  int res14 = SWIG_TMPOBJ ;
  PyArrayObject *pyarr15 = NULL ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr10 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr10)) {
        handle_malloc_failure("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg10 = (SpiceDouble *) PyArray_DATA(pyarr10);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr10, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg11 = &temp11;
  arg12 = &temp12;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg13 = (SpiceDouble *) PyArray_DATA(pyarr13);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr13, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  arg14 = &temp14;
  {
    //      (SpiceDouble OUT_ARRAY1[ANY])
    
    npy_intp dims[1] = {
      3
    };                               // DIMENSIONS
    pyarr15 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr15)) {
        handle_malloc_failure("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg15 = (SpiceDouble *) PyArray_DATA(pyarr15);                                // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr15, 0);                            // DIM1
    //  $3 = &size[0];                                              // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "tangpt", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "tangpt" "', argument " "3"" of type '" "SpiceDouble""'");
  } 
  arg3 = (SpiceDouble)(val3);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr9 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr9){
        handle_bad_array_conversion("tangpt", NPY_DOUBLE, swig_obj[8], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr9) && (PyArray_DIM(pyarr9, 0) != (3))) {
        handle_invalid_array_shape_1d("tangpt", pyarr9, 3);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg9 = (ConstSpiceDouble *) PyArray_DATA(pyarr9);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr9, 0);                            // DIM1
  }
  tangpt_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tangpt");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr10);
    // AppendOutput steals the reference to the argument.
    pyarr10 = NULL;
  }
  if (SWIG_IsTmpObj(res11)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg11)));
  } else {
    int new_flags = SWIG_IsNewObj(res11) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg11), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res12)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg12)));
  } else {
    int new_flags = SWIG_IsNewObj(res12) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg12), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  if (SWIG_IsTmpObj(res14)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg14)));
  } else {
    int new_flags = SWIG_IsNewObj(res14) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg14), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr15);
    // AppendOutput steals the reference to the argument.
    pyarr15 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr15);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr9);
  }
  {
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
  }
  {
    Py_XDECREF(pyarr15);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tangpt_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  int arg4 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  ConstSpiceDouble *arg10 = (ConstSpiceDouble *) 0 ;
  int arg11 ;
  int arg12 ;
  SpiceDouble **arg13 = (SpiceDouble **) 0 ;
  int *arg14 = (int *) 0 ;
  int *arg15 = (int *) 0 ;
  SpiceDouble **arg16 = (SpiceDouble **) 0 ;
  int *arg17 = (int *) 0 ;
  SpiceDouble **arg18 = (SpiceDouble **) 0 ;
  int *arg19 = (int *) 0 ;
  SpiceDouble **arg20 = (SpiceDouble **) 0 ;
  int *arg21 = (int *) 0 ;
  int *arg22 = (int *) 0 ;
  SpiceDouble **arg23 = (SpiceDouble **) 0 ;
  int *arg24 = (int *) 0 ;
  SpiceDouble **arg25 = (SpiceDouble **) 0 ;
  int *arg26 = (int *) 0 ;
  int *arg27 = (int *) 0 ;
  int alloc1 = 0 ;
  int alloc2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  PyArrayObject *pyarr10 = NULL ;
  PyArrayObject *pyarr13 = NULL ;
  SpiceDouble *buffer13 = NULL ;
  int dimsize13[2] ;
  PyArrayObject *pyarr16 = NULL ;
  SpiceDouble *buffer16 = NULL ;
  int dimsize16[1] ;
  PyArrayObject *pyarr18 = NULL ;
  SpiceDouble *buffer18 = NULL ;
  int dimsize18[1] ;
  PyArrayObject *pyarr20 = NULL ;
  SpiceDouble *buffer20 = NULL ;
  int dimsize20[2] ;
  PyArrayObject *pyarr23 = NULL ;
  SpiceDouble *buffer23 = NULL ;
  int dimsize23[1] ;
  PyArrayObject *pyarr25 = NULL ;
  SpiceDouble *buffer25 = NULL ;
  int dimsize25[2] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg13 = &buffer13;                                               // ARRAY
    arg14 = &dimsize13[0];                                           // SIZE1
    arg15 = &dimsize13[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg16 = &buffer16;                                               // ARRAY
    arg17 = &dimsize16[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg18 = &buffer18;                                               // ARRAY
    arg19 = &dimsize18[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg20 = &buffer20;                                               // ARRAY
    arg21 = &dimsize20[0];                                           // SIZE1
    arg22 = &dimsize20[1];                                           // SIZE2
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg23 = &buffer23;                                               // ARRAY
    arg24 = &dimsize23[0];                                           // SIZE1
  }
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg25 = &buffer25;                                               // ARRAY
    arg26 = &dimsize25[0];                                           // SIZE1
    arg27 = &dimsize25[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "tangpt_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("tangpt_vector", NPY_DOUBLE, swig_obj[2], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    if (PyArray_NDIM(pyarr3) == 0) {
      arg4 = 0;                                                 // DIM1
    } else {
      arg4 = (int) PyArray_DIM(pyarr3, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr10 = PyArray_FROMANY(swig_obj[8], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr10){
        handle_bad_array_conversion("tangpt_vector", NPY_DOUBLE, swig_obj[8], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr10) == 1) {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = 0;                                                 // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 0);                        // DIM2
    } else {
      arg10 = (ConstSpiceDouble *) PyArray_DATA(pyarr10);                    // ARRAY
      arg11 = (int) PyArray_DIM(pyarr10, 0);                        // DIM1
      arg12 = (int) PyArray_DIM(pyarr10, 1);                        // DIM2
    }
  }
  tangpt_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21,arg22,arg23,arg24,arg25,arg26,arg27);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer13)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize13[0], dimsize13[1]
    };
    if (dimsize13[0] == 0) {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr13 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr13)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr13), buffer13,
      PyArray_SIZE(pyarr13) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr13);
    // AppendOutput steals the reference to the argument.
    pyarr13 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer16)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize16[0], 1);
    pyarr16 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr16)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr16), buffer16, dim * sizeof(SpiceDouble));
    if (dimsize16[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr16, PyArray_DATA(pyarr16));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("tangpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr16 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr16);
      // AppendOutput steals the reference to the argument.
      pyarr16 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer18)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize18[0], 1);
    pyarr18 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr18)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr18), buffer18, dim * sizeof(SpiceDouble));
    if (dimsize18[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr18, PyArray_DATA(pyarr18));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("tangpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr18 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr18);
      // AppendOutput steals the reference to the argument.
      pyarr18 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer20)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize20[0], dimsize20[1]
    };
    if (dimsize20[0] == 0) {
      pyarr20 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr20 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr20)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr20), buffer20,
      PyArray_SIZE(pyarr20) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr20);
    // AppendOutput steals the reference to the argument.
    pyarr20 = NULL;
  }
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer23)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize23[0], 1);
    pyarr23 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr23)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr23), buffer23, dim * sizeof(SpiceDouble));
    if (dimsize23[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr23, PyArray_DATA(pyarr23));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("tangpt_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr23 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr23);
      // AppendOutput steals the reference to the argument.
      pyarr23 = NULL;
    }
  }
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer25)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize25[0], dimsize25[1]
    };
    if (dimsize25[0] == 0) {
      pyarr25 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr25 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr25)) {
        handle_malloc_failure("tangpt_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr25), buffer25,
      PyArray_SIZE(pyarr25) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr25);
    // AppendOutput steals the reference to the argument.
    pyarr25 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  {
    Py_XDECREF(pyarr23);
    PyMem_Free((void *) buffer23);
  }
  {
    Py_XDECREF(pyarr25);
    PyMem_Free((void *) buffer25);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr10);
  }
  {
    Py_XDECREF(pyarr13);
    PyMem_Free((void *) buffer13);
  }
  {
    Py_XDECREF(pyarr16);
    PyMem_Free((void *) buffer16);
  }
  {
    Py_XDECREF(pyarr18);
    PyMem_Free((void *) buffer18);
  }
  {
    Py_XDECREF(pyarr20);
    PyMem_Free((void *) buffer20);
  }
  {
    Py_XDECREF(pyarr23);
    PyMem_Free((void *) buffer23);
  }
  {
    Py_XDECREF(pyarr25);
    PyMem_Free((void *) buffer25);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tkfram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceInt arg1 ;
  SpiceDouble (*arg2)[3] ;
  SpiceInt *arg3 = (SpiceInt *) 0 ;
  SpiceBoolean *arg4 = (SpiceBoolean *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  SpiceInt temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceBoolean mybool4 ;
  PyObject *swig_obj[1] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      3, 3
    };               // ARRAY
    pyarr2 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr2)) {
        handle_malloc_failure("tkfram");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg2 = (SpiceDouble (*)[3]) PyArray_DATA(pyarr2);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr2, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  arg3 = &temp3;
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    arg4 = &mybool4;
  }
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  ecode1 = SWIG_AsVal_int(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "tkfram" "', argument " "1"" of type '" "SpiceInt""'");
  } 
  arg1 = (SpiceInt)(val1);
  tkfram_c(arg1,(SpiceDouble (*)[3])arg2,arg3,arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tkfram");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr2);
    // AppendOutput steals the reference to the argument.
    pyarr2 = NULL;
  }
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (SpiceBoolean *OUT_BOOLEAN)
    
    long test = (*arg4 != 0);
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong(test));
  }
  {
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_tparch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceChar *arg1 = (ConstSpiceChar *) 0 ;
  int alloc1 = 0 ;
  PyObject *swig_obj[1] ;
  
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("tparch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[0], (char **)&arg1, NULL, &alloc1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("tparch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  tparch_c(arg1);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("tparch");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trgsep(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  ConstSpiceChar *arg2 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  double val1 ;
  int ecode1 = 0 ;
  int alloc2 = 0 ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  PyObject *swig_obj[9] ;
  SpiceDouble result;
  
  if (!SWIG_Python_UnpackTuple(args, "trgsep", 9, 9, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "trgsep" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg2, NULL, &alloc2);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  result = trgsep_c(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trgsep");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyFloat_FromDouble((double) result));
  }
  return resultobj;
fail:
  return NULL;
}


SWIGINTERN PyObject *_wrap_trgsep_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg4 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg5 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg6 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg7 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg8 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg9 = (ConstSpiceChar *) 0 ;
  ConstSpiceChar *arg10 = (ConstSpiceChar *) 0 ;
  SpiceDouble **arg11 = (SpiceDouble **) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  int alloc4 = 0 ;
  int alloc5 = 0 ;
  int alloc6 = 0 ;
  int alloc7 = 0 ;
  int alloc8 = 0 ;
  int alloc9 = 0 ;
  int alloc10 = 0 ;
  PyArrayObject *pyarr11 = NULL ;
  SpiceDouble *buffer11 = NULL ;
  int dimsize11[1] ;
  PyObject *swig_obj[9] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    arg11 = &buffer11;                                               // ARRAY
    arg12 = &dimsize11[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "trgsep_vector", 9, 9, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY01, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 0, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("trgsep_vector", NPY_DOUBLE, swig_obj[0], 0, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    if (PyArray_NDIM(pyarr1) == 0) {
      arg2 = 0;                                                 // DIM1
    } else {
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
    }
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[2]) : !PyString_Check(swig_obj[2])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[2], (char **)&arg4, NULL, &alloc4);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[3]) : !PyString_Check(swig_obj[3])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[3], (char **)&arg5, NULL, &alloc5);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[4]) : !PyString_Check(swig_obj[4])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[4], (char **)&arg6, NULL, &alloc6);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[5]) : !PyString_Check(swig_obj[5])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[5], (char **)&arg7, NULL, &alloc7);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[6]) : !PyString_Check(swig_obj[6])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[6], (char **)&arg8, NULL, &alloc8);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[7]) : !PyString_Check(swig_obj[7])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[7], (char **)&arg9, NULL, &alloc9);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[8]) : !PyString_Check(swig_obj[8])) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[8], (char **)&arg10, NULL, &alloc10);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  trgsep_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    //      (SpiceDouble **OUT_ARRAY01, int *SIZE1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer11)) {
        handle_malloc_failure("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dim = max(dimsize11[0], 1);
    pyarr11 = (PyArrayObject *) PyArray_SimpleNew(1, &dim, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr11)) {
        handle_malloc_failure("trgsep_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr11), buffer11, dim * sizeof(SpiceDouble));
    if (dimsize11[0] == 0) {
      PyObject* value = PyArray_GETITEM(pyarr11, PyArray_DATA(pyarr11));
      /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
      {
        if (!(value)) {
          handle_malloc_failure("trgsep_vector");
          SWIG_fail;
        }
      }
      /*@SWIG@*/;
      // AppendOutput steals the reference to this object, so we don't need DECREF
      // pyarr11 is cleaned up by the freearg
      resultobj = SWIG_Python_AppendOutput(resultobj, value);
    } else {
      resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr11);
      // AppendOutput steals the reference to the argument.
      pyarr11 = NULL;
    }
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    Py_XDECREF(pyarr11);
    PyMem_Free((void *) buffer11);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_twovxf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 ;
  SpiceInt arg4 ;
  SpiceDouble (*arg5)[6] ;
  PyArrayObject *pyarr1 = NULL ;
  int val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      6, 6
    };               // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("twovxf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    //  dimsize[0] = (int) dims[0];
    //  dimsize[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[6]) PyArray_DATA(pyarr5);                        // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr5, 0);                           // DIM1
    //  $3 = (int) PyArray_DIM(pyarr5, 1);                           // DIM2
    //  $4 = &dimsize[0];                                           // SIZE1
    //  $5 = &dimsize[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "twovxf", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("twovxf", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 0) != (6))) {
        handle_invalid_array_shape_1d("twovxf", pyarr1, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "twovxf" "', argument " "2"" of type '" "SpiceInt""'");
  } 
  arg2 = (SpiceInt)(val2);
  {
    //      (ConstSpiceDouble IN_ARRAY1[ANY])
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("twovxf", NPY_DOUBLE, swig_obj[2], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,577,TEST_INVALID_ARRAY_SHAPE_1D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 0) != (6))) {
        handle_invalid_array_shape_1d("twovxf", pyarr3, 6);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    //  $2 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  ecode4 = SWIG_AsVal_int(swig_obj[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "twovxf" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  twovxf_c(arg1,arg2,arg3,arg4,(SpiceDouble (*)[6])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("twovxf");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_twovxf_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  SpiceInt arg4 ;
  ConstSpiceDouble *arg5 = (ConstSpiceDouble *) 0 ;
  int arg6 ;
  int arg7 ;
  SpiceInt arg8 ;
  SpiceDouble **arg9 = (SpiceDouble **) 0 ;
  int *arg10 = (int *) 0 ;
  int *arg11 = (int *) 0 ;
  int *arg12 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  int val4 ;
  int ecode4 = 0 ;
  PyArrayObject *pyarr5 = NULL ;
  int val8 ;
  int ecode8 = 0 ;
  PyArrayObject *pyarr9 = NULL ;
  SpiceDouble *buffer9 = NULL ;
  int dimsize9[3] ;
  PyObject *swig_obj[4] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    arg9 = &buffer9;                                               // ARRAY
    arg10 = &dimsize9[0];                                           // SIZE1
    arg11 = &dimsize9[1];                                           // SIZE2
    arg12 = &dimsize9[2];                                           // SIZE3
  }
  if (!SWIG_Python_UnpackTuple(args, "twovxf_vector", 4, 4, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("twovxf_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  ecode4 = SWIG_AsVal_int(swig_obj[1], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "twovxf_vector" "', argument " "4"" of type '" "SpiceInt""'");
  } 
  arg4 = (SpiceInt)(val4);
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr5 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr5){
        handle_bad_array_conversion("twovxf_vector", NPY_DOUBLE, swig_obj[2], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr5) == 1) {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = 0;                                                 // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 0);                        // DIM2
    } else {
      arg5 = (ConstSpiceDouble *) PyArray_DATA(pyarr5);                    // ARRAY
      arg6 = (int) PyArray_DIM(pyarr5, 0);                        // DIM1
      arg7 = (int) PyArray_DIM(pyarr5, 1);                        // DIM2
    }
  }
  ecode8 = SWIG_AsVal_int(swig_obj[3], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "twovxf_vector" "', argument " "8"" of type '" "SpiceInt""'");
  } 
  arg8 = (SpiceInt)(val8);
  twovxf_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("twovxf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY23, int *SIZE1, int *SIZE2, int *SIZE3)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer9)) {
        handle_malloc_failure("twovxf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[3] = {
      dimsize9[0], dimsize9[1], dimsize9[2]
    };
    if (dims[0] == 0) {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(2, dims + 1, NPY_DOUBLE);
    } else  {
      pyarr9 = (PyArrayObject *) PyArray_SimpleNew(3, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr9)) {
        handle_malloc_failure("twovxf_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr9), buffer9,
      PyArray_SIZE(pyarr9) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr9);
    pyarr9 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr5);
  }
  {
    Py_XDECREF(pyarr9);
    PyMem_Free((void *) buffer9);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprojg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble **arg5 = (SpiceDouble **) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  SpiceDouble *buffer5 = NULL ;
  int dimsize5[1] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    
    arg5 = &buffer5;                                               // ARRAY
    arg6 = &dimsize5[0];                                           // SIZE1
  }
  if (!SWIG_Python_UnpackTuple(args, "vprojg", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprojg", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("vprojg", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  my_vprojg_c(arg1,arg2,arg3,arg4,arg5,arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprojg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY1, int *SIZE1)
    //      (int *SIZE1, SpiceDouble **OUT_ARRAY1)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer5)) {
        handle_malloc_failure("vprojg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[1] = {
      dimsize5[0]
    };
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(1, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("vprojg");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr5), buffer5, dims[0] * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
    PyMem_Free((void *) buffer5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_my_vprojg_nomalloc(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg2 ;
  ConstSpiceDouble *arg3 = (ConstSpiceDouble *) 0 ;
  SpiceInt arg4 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  PyObject *swig_obj[3] ;
  
  arg5 = &temp5;
  if (!SWIG_Python_UnpackTuple(args, "my_vprojg_nomalloc", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("my_vprojg_nomalloc", NPY_DOUBLE, swig_obj[0], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                          // ARRAY
    arg2 = (int) PyArray_DIM(pyarr1, 0);                            // DIM1
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY1, int DIM1)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 1, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("my_vprojg_nomalloc", NPY_DOUBLE, swig_obj[1], 1, 1);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    arg3 = (ConstSpiceDouble *) PyArray_DATA(pyarr3);                          // ARRAY
    arg4 = (int) PyArray_DIM(pyarr3, 0);                            // DIM1
  }
  res6 = SWIG_ConvertPtr(swig_obj[2], &argp6,SWIGTYPE_p_SpiceInt, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "my_vprojg_nomalloc" "', argument " "6"" of type '" "SpiceInt *""'"); 
  }
  arg6 = (SpiceInt *)(argp6);
  my_vprojg_nomalloc(arg1,arg2,arg3,arg4,arg5,arg6);
  resultobj = SWIG_Py_Void();
  
  
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY1[ANY]...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_vprojg_vector(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  ConstSpiceDouble *arg1 = (ConstSpiceDouble *) 0 ;
  int arg2 ;
  int arg3 ;
  ConstSpiceDouble *arg4 = (ConstSpiceDouble *) 0 ;
  int arg5 ;
  int arg6 ;
  SpiceDouble **arg7 = (SpiceDouble **) 0 ;
  int *arg8 = (int *) 0 ;
  int *arg9 = (int *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  PyArrayObject *pyarr7 = NULL ;
  SpiceDouble *buffer7 = NULL ;
  int dimsize7[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (SpiceDouble **OUT_ARRAY2, int *SIZE1, int *SIZE2)
    
    arg7 = &buffer7;                                               // ARRAY
    arg8 = &dimsize7[0];                                           // SIZE1
    arg9 = &dimsize7[1];                                           // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "vprojg_vector", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("vprojg_vector", NPY_DOUBLE, swig_obj[0], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr1) == 1) {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = 0;                                                 // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 0);                        // DIM2
    } else {
      arg1 = (ConstSpiceDouble *) PyArray_DATA(pyarr1);                    // ARRAY
      arg2 = (int) PyArray_DIM(pyarr1, 0);                        // DIM1
      arg3 = (int) PyArray_DIM(pyarr1, 1);                        // DIM2
    }
  }
  {
    //      (ConstSpiceDouble *IN_ARRAY12, int DIM1, int DIM2)
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 1, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("vprojg_vector", NPY_DOUBLE, swig_obj[1], 1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    
    if (PyArray_NDIM(pyarr4) == 1) {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = 0;                                                 // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 0);                        // DIM2
    } else {
      arg4 = (ConstSpiceDouble *) PyArray_DATA(pyarr4);                    // ARRAY
      arg5 = (int) PyArray_DIM(pyarr4, 0);                        // DIM1
      arg6 = (int) PyArray_DIM(pyarr4, 1);                        // DIM2
    }
  }
  vprojg_vector(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("vprojg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    //      (SpiceDouble **OUT_ARRAY12, int *SIZE1, int *SIZE2)
    
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(buffer7)) {
        handle_malloc_failure("vprojg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    npy_intp dims[2] = {
      dimsize7[0], dimsize7[1]
    };
    if (dimsize7[0] == 0) {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(1, dims + 1, NPY_DOUBLE);
    } else {
      pyarr7 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    }
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr7)) {
        handle_malloc_failure("vprojg_vector");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    memcpy(PyArray_DATA(pyarr7), buffer7,
      PyArray_SIZE(pyarr7) * sizeof(SpiceDouble));
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *) pyarr7);
    // AppendOutput steals the reference to the argument.
    pyarr7 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  {
    Py_XDECREF(pyarr7);
    PyMem_Free((void *) buffer7);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wncomd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  int arg3 ;
  SpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wncomd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wncomd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wncomd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wncomd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wncomd", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wncomd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wncomd_c(arg1,arg2,arg3,(SpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wncomd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wncond(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  int arg3 ;
  SpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wncond");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wncond", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wncond" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wncond" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wncond", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wncond", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wncond_c(arg1,arg2,arg3,(SpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wncond");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wndifd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  ConstSpiceDouble (*arg2)[2] ;
  int arg3 ;
  ConstSpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wndifd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wndifd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("wndifd", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_x2d("wndifd", pyarr1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wndifd", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wndifd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wndifd_c(arg1,(ConstSpiceDouble (*)[2])arg2,arg3,(ConstSpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wndifd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnelmd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  int arg2 ;
  SpiceDouble (*arg3)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyObject *swig_obj[2] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "wnelmd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wnelmd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("wnelmd", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnelmd", pyarr2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr2);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
  }
  result = my_wnelmd_c(arg1,arg2,(SpiceDouble (*)[2])arg3);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnelmd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnexpd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  int arg3 ;
  SpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wnexpd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnexpd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wnexpd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wnexpd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wnexpd", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnexpd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wnexpd_c(arg1,arg2,arg3,(SpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnexpd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnextd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceChar arg1 ;
  int arg2 ;
  SpiceDouble (*arg3)[2] ;
  int *arg4 = (int *) 0 ;
  SpiceDouble (*arg5)[2] ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("wnextd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize4[0] = (int) dims[0];
    dimsize4[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr4);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr4, 1);                            // DIM2
    arg4 = &dimsize4[0];                                            // SIZE1
    //  $5 = &dimsize4[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnextd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (SpiceChar IN_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[0]) : !PyString_Check(swig_obj[0])) {
        handle_bad_string_error("wnextd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error  = SWIG_AsVal_char(swig_obj[0], &arg1);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("wnextd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("wnextd", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnextd", pyarr2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr2);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
  }
  my_wnextd_c(arg1,arg2,(SpiceDouble (*)[2])arg3,arg4,(SpiceDouble (*)[2])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnextd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  {
    
  }
  
  {
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnfild(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  int arg2 ;
  SpiceDouble (*arg3)[2] ;
  int *arg4 = (int *) 0 ;
  SpiceDouble (*arg5)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("wnfild");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize4[0] = (int) dims[0];
    dimsize4[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr4);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr4, 1);                            // DIM2
    arg4 = &dimsize4[0];                                            // SIZE1
    //  $5 = &dimsize4[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnfild", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wnfild" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("wnfild", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnfild", pyarr2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr2);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
  }
  my_wnfild_c(arg1,arg2,(SpiceDouble (*)[2])arg3,arg4,(SpiceDouble (*)[2])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnfild");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnfltd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  int arg2 ;
  ConstSpiceDouble (*arg3)[2] ;
  int *arg4 = (int *) 0 ;
  SpiceDouble (*arg5)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  PyArrayObject *pyarr2 = NULL ;
  PyArrayObject *pyarr4 = NULL ;
  int dimsize4[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr4 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr4)) {
        handle_malloc_failure("wnfltd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize4[0] = (int) dims[0];
    dimsize4[1] = (int) dims[1];
    
    arg5 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr4);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr4, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr4, 1);                            // DIM2
    arg4 = &dimsize4[0];                                            // SIZE1
    //  $5 = &dimsize4[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnfltd", 2, 2, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wnfltd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  {
    //      (int DIM1, SpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, SpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr2 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr2){
        handle_bad_array_conversion("wnfltd", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr2) && (PyArray_DIM(pyarr2, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnfltd", pyarr2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg3 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr2);                                // ARRAY
    arg2 = (int) PyArray_DIM(pyarr2, 0);                           // DIM1
  }
  my_wnfltd_c(arg1,arg2,(ConstSpiceDouble (*)[2])arg3,arg4,(SpiceDouble (*)[2])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnfltd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize4[0], dimsize4[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr4, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr4);
    // AppendOutput steals the reference to the argument.
    pyarr4 = NULL;
  }
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (SpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr2);
  }
  {
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnincd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  int arg3 ;
  ConstSpiceDouble (*arg4)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "wnincd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wnincd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wnincd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wnincd", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnincd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  result = my_wnincd_c(arg1,arg2,arg3,(ConstSpiceDouble (*)[2])arg4);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnincd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wninsd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  SpiceDouble arg1 ;
  SpiceDouble arg2 ;
  int arg3 ;
  ConstSpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  double val1 ;
  int ecode1 = 0 ;
  double val2 ;
  int ecode2 = 0 ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[3] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wninsd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wninsd", 3, 3, swig_obj)) SWIG_fail;
  ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "wninsd" "', argument " "1"" of type '" "SpiceDouble""'");
  } 
  arg1 = (SpiceDouble)(val1);
  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "wninsd" "', argument " "2"" of type '" "SpiceDouble""'");
  } 
  arg2 = (SpiceDouble)(val2);
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wninsd", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wninsd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wninsd_c(arg1,arg2,arg3,(ConstSpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wninsd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnintd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  ConstSpiceDouble (*arg2)[2] ;
  int arg3 ;
  ConstSpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wnintd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnintd", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("wnintd", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnintd", pyarr1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wnintd", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnintd", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wnintd_c(arg1,(ConstSpiceDouble (*)[2])arg2,arg3,(ConstSpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnintd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnreld(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  ConstSpiceDouble (*arg2)[2] ;
  ConstSpiceChar *arg3 = (ConstSpiceChar *) 0 ;
  int arg4 ;
  ConstSpiceDouble (*arg5)[2] ;
  PyArrayObject *pyarr1 = NULL ;
  int alloc3 = 0 ;
  PyArrayObject *pyarr4 = NULL ;
  PyObject *swig_obj[3] ;
  SpiceBoolean result;
  
  if (!SWIG_Python_UnpackTuple(args, "wnreld", 3, 3, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("wnreld", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnreld", pyarr1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (ConstSpiceChar *CONST_STRING)
    
    /*@SWIG:swig/cspyce_typemaps.i,545,TEST_IS_STRING@*/
    {
      if (is_python_3xx ? !PyUnicode_Check(swig_obj[1]) : !PyString_Check(swig_obj[1])) {
        handle_bad_string_error("wnreld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    int error = SWIG_AsCharPtrAndSize(swig_obj[1], (char **)&arg3, NULL, &alloc3);
    /*@SWIG:swig/cspyce_typemaps.i,554,RAISE_BAD_STRING_ON_ERROR@*/
    {
      if (!SWIG_IsOK(error)) {
        handle_bad_string_error("wnreld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr4 = PyArray_FROMANY(swig_obj[2], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr4){
        handle_bad_array_conversion("wnreld", NPY_DOUBLE, swig_obj[2], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr4) && (PyArray_DIM(pyarr4, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnreld", pyarr4, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg5 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr4);                                // ARRAY
    arg4 = (int) PyArray_DIM(pyarr4, 0);                           // DIM1
  }
  result = my_wnreld_c(arg1,(ConstSpiceDouble (*)[2])arg2,arg3,arg4,(ConstSpiceDouble (*)[2])arg5);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnreld");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    resultobj = SWIG_Python_AppendOutput(resultobj, PyBool_FromLong((long) result));
  }
  
  
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr4);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnsumd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  ConstSpiceDouble (*arg2)[2] ;
  SpiceDouble *arg3 = (SpiceDouble *) 0 ;
  SpiceDouble *arg4 = (SpiceDouble *) 0 ;
  SpiceDouble *arg5 = (SpiceDouble *) 0 ;
  SpiceInt *arg6 = (SpiceInt *) 0 ;
  SpiceInt *arg7 = (SpiceInt *) 0 ;
  PyArrayObject *pyarr1 = NULL ;
  SpiceDouble temp3 ;
  int res3 = SWIG_TMPOBJ ;
  SpiceDouble temp4 ;
  int res4 = SWIG_TMPOBJ ;
  SpiceDouble temp5 ;
  int res5 = SWIG_TMPOBJ ;
  SpiceInt temp6 ;
  int res6 = SWIG_TMPOBJ ;
  SpiceInt temp7 ;
  int res7 = SWIG_TMPOBJ ;
  PyObject *swig_obj[1] ;
  
  arg3 = &temp3;
  arg4 = &temp4;
  arg5 = &temp5;
  arg6 = &temp6;
  arg7 = &temp7;
  if (!args) SWIG_fail;
  swig_obj[0] = args;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("wnsumd", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnsumd", pyarr1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  my_wnsumd_c(arg1,(ConstSpiceDouble (*)[2])arg2,arg3,arg4,arg5,arg6,arg7);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnsumd");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  if (SWIG_IsTmpObj(res3)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg3)));
  } else {
    int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res4)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg4)));
  } else {
    int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res5)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg5)));
  } else {
    int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_SpiceDouble, new_flags));
  }
  if (SWIG_IsTmpObj(res6)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
  } else {
    int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_SpiceInt, new_flags));
  }
  if (SWIG_IsTmpObj(res7)) {
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
  } else {
    int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN |  0 ) :  0 ;
    resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_SpiceInt, new_flags));
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  return NULL;
}


SWIGINTERN PyObject *_wrap_wnunid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
  PyObject *resultobj = 0;
  int arg1 ;
  ConstSpiceDouble (*arg2)[2] ;
  int arg3 ;
  ConstSpiceDouble (*arg4)[2] ;
  int *arg5 = (int *) 0 ;
  SpiceDouble (*arg6)[2] ;
  PyArrayObject *pyarr1 = NULL ;
  PyArrayObject *pyarr3 = NULL ;
  PyArrayObject *pyarr5 = NULL ;
  int dimsize5[2] ;
  PyObject *swig_obj[2] ;
  
  {
    //      (int *SIZE1, SpiceDouble OUT_ARRAY2[ANY][ANY])
    
    npy_intp dims[2] = {
      WINDOWS, 2
    };                      // ARRAY
    pyarr5 = (PyArrayObject *) PyArray_SimpleNew(2, dims, NPY_DOUBLE);
    /*@SWIG:swig/cspyce_typemaps.i,524,TEST_MALLOC_FAILURE@*/
    {
      if (!(pyarr5)) {
        handle_malloc_failure("wnunid");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    dimsize5[0] = (int) dims[0];
    dimsize5[1] = (int) dims[1];
    
    arg6 = (SpiceDouble (*)[2]) PyArray_DATA(pyarr5);                         // ARRAY
    //  $3 = (int) PyArray_DIM(pyarr5, 0);                            // DIM1
    //  $4 = (int) PyArray_DIM(pyarr5, 1);                            // DIM2
    arg5 = &dimsize5[0];                                            // SIZE1
    //  $5 = &dimsize5[1];                                            // SIZE2
  }
  if (!SWIG_Python_UnpackTuple(args, "wnunid", 2, 2, swig_obj)) SWIG_fail;
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr1 = PyArray_FROMANY(swig_obj[0], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr1){
        handle_bad_array_conversion("wnunid", NPY_DOUBLE, swig_obj[0], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr1) && (PyArray_DIM(pyarr1, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnunid", pyarr1, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg2 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr1);                                // ARRAY
    arg1 = (int) PyArray_DIM(pyarr1, 0);                           // DIM1
  }
  {
    //      (int DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    //      (SpiceInt DIM1, ConstSpiceDouble IN_ARRAY2[][ANY])
    
    /*@SWIG:swig/cspyce_typemaps.i,658,CONVERT_TO_CONTIGUOUS_ARRAY@*/
    {
      pyarr3 = PyArray_FROMANY(swig_obj[1], NPY_DOUBLE, 2, 2, NPY_ARRAY_CARRAY_RO); // readonly okay
      if (!pyarr3){
        handle_bad_array_conversion("wnunid", NPY_DOUBLE, swig_obj[1], 2, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/
    /*@SWIG:swig/cspyce_typemaps.i,631,TEST_INVALID_ARRAY_SHAPE_x2D@*/
    {
      if ((pyarr3) && (PyArray_DIM(pyarr3, 1) != (2))) {
        handle_invalid_array_shape_x2d("wnunid", pyarr3, 2);
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    
    arg4 = (ConstSpiceDouble (*)[2]) PyArray_DATA(pyarr3);                                // ARRAY
    arg3 = (int) PyArray_DIM(pyarr3, 0);                           // DIM1
  }
  my_wnunid_c(arg1,(ConstSpiceDouble (*)[2])arg2,arg3,(ConstSpiceDouble (*)[2])arg4,arg5,(SpiceDouble (*)[2])arg6);
  {
    /*@SWIG:swig/cspyce_typemaps.i,480,TEST_FOR_EXCEPTION@*/{
      if (failed_c()) {
        handle_swig_exception("wnunid");
        SWIG_fail;
      }
    }
    /*@SWIG@*/;
    if (!resultobj) {
      resultobj = (Py_INCREF(Py_None), Py_None);
    }
  }
  
  
  {
    npy_intp dims[2] = {
      dimsize5[0], dimsize5[1]
    };
    PyArray_Dims shape = {
      dims, 2
    };
    
    PyArray_Resize(pyarr5, &shape, 0, NPY_CORDER);
    resultobj = SWIG_Python_AppendOutput(resultobj, (PyObject *)pyarr5);
    // AppendOutput steals the reference to the argument.
    pyarr5 = NULL;
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return resultobj;
fail:
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr1);
  }
  {
    //      (ConstSpiceDouble ...IN_ARRAY2...)
    Py_XDECREF(pyarr3);
  }
  {
    Py_XDECREF(pyarr5);
  }
  return NULL;
}


static PyMethodDef SwigMethods[] = {
	 { "SWIG_PyInstanceMethod_New", SWIG_PyInstanceMethod_New, METH_O, NULL},
	 { "axisar", _wrap_axisar, METH_VARARGS, "axisar(ConstSpiceDouble [3] axis, SpiceDouble angle)"},
	 { "axisar_vector", _wrap_axisar_vector, METH_VARARGS, "axisar_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"},
	 { "b1900", _wrap_b1900, METH_NOARGS, "b1900() -> SpiceDouble"},
	 { "b1950", _wrap_b1950, METH_NOARGS, "b1950() -> SpiceDouble"},
	 { "bltfrm", _wrap_bltfrm, METH_O, "bltfrm(SpiceInt frmcls)"},
	 { "bodc2n", _wrap_bodc2n, METH_O, "bodc2n(SpiceInt code)"},
	 { "bodc2s", _wrap_bodc2s, METH_O, "bodc2s(SpiceInt code)"},
	 { "boddef", _wrap_boddef, METH_VARARGS, "boddef(ConstSpiceChar * CONST_STRING, SpiceInt code)"},
	 { "bodfnd", _wrap_bodfnd, METH_VARARGS, "bodfnd(SpiceInt body, ConstSpiceChar * CONST_STRING) -> SpiceBoolean"},
	 { "bodn2c", _wrap_bodn2c, METH_O, "bodn2c(ConstSpiceChar * CONST_STRING)"},
	 { "bods2c", _wrap_bods2c, METH_O, "bods2c(ConstSpiceChar * CONST_STRING)"},
	 { "bodvar", _wrap_bodvar, METH_VARARGS, "bodvar(SpiceInt body, ConstSpiceChar * CONST_STRING)"},
	 { "bodvcd", _wrap_bodvcd, METH_VARARGS, "bodvcd(SpiceInt bodyid, ConstSpiceChar * CONST_STRING)"},
	 { "bodvrd", _wrap_bodvrd, METH_VARARGS, "bodvrd(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"},
	 { "ccifrm", _wrap_ccifrm, METH_VARARGS, "ccifrm(SpiceInt frclss, SpiceInt clssid)"},
	 { "cgv2el", _wrap_cgv2el, METH_VARARGS, "cgv2el(ConstSpiceDouble [3] center, ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"},
	 { "cgv2el_vector", _wrap_cgv2el_vector, METH_VARARGS, "cgv2el_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "chkin", _wrap_chkin, METH_O, "chkin(ConstSpiceChar * CONST_STRING)"},
	 { "chkout", _wrap_chkout, METH_O, "chkout(ConstSpiceChar * CONST_STRING)"},
	 { "cidfrm", _wrap_cidfrm, METH_O, "cidfrm(SpiceInt cent)"},
	 { "ckcov", _wrap_ckcov, METH_VARARGS, "ckcov(ConstSpiceChar * ck, SpiceInt idcode, SpiceBoolean needav, ConstSpiceChar * level, SpiceDouble tol, ConstSpiceChar * timsys)"},
	 { "ckgp", _wrap_ckgp, METH_VARARGS, "ckgp(SpiceInt inst, SpiceDouble sclkdp, SpiceDouble tol, ConstSpiceChar * CONST_STRING)"},
	 { "ckgp_vector", _wrap_ckgp_vector, METH_VARARGS, "ckgp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceChar * str1)"},
	 { "ckgpav", _wrap_ckgpav, METH_VARARGS, "ckgpav(SpiceInt inst, SpiceDouble sclkdp, SpiceDouble tol, ConstSpiceChar * CONST_STRING)"},
	 { "ckgpav_vector", _wrap_ckgpav_vector, METH_VARARGS, "ckgpav_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceChar * str1)"},
	 { "ckobj", _wrap_ckobj, METH_O, "ckobj(ConstSpiceChar * ck)"},
	 { "clight", _wrap_clight, METH_NOARGS, "clight() -> SpiceDouble"},
	 { "clpool", _wrap_clpool, METH_NOARGS, "clpool()"},
	 { "cnmfrm", _wrap_cnmfrm, METH_O, "cnmfrm(ConstSpiceChar * cname)"},
	 { "conics", _wrap_conics, METH_VARARGS, "conics(ConstSpiceDouble [8] elts, SpiceDouble et)"},
	 { "conics_vector", _wrap_conics_vector, METH_VARARGS, "conics_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"},
	 { "convrt", _wrap_convrt, METH_VARARGS, "convrt(SpiceDouble x, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"},
	 { "convrt_vector", _wrap_convrt_vector, METH_VARARGS, "convrt_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"},
	 { "cyllat", _wrap_cyllat, METH_VARARGS, "cyllat(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"},
	 { "cyllat_vector", _wrap_cyllat_vector, METH_VARARGS, "cyllat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "cylrec", _wrap_cylrec, METH_VARARGS, "cylrec(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"},
	 { "cylrec_vector", _wrap_cylrec_vector, METH_VARARGS, "cylrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "cylsph", _wrap_cylsph, METH_VARARGS, "cylsph(SpiceDouble r, SpiceDouble lonc, SpiceDouble z)"},
	 { "cylsph_vector", _wrap_cylsph_vector, METH_VARARGS, "cylsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "dafbfs", _wrap_dafbfs, METH_O, "dafbfs(SpiceInt handle)"},
	 { "dafcls", _wrap_dafcls, METH_O, "dafcls(SpiceInt handle)"},
	 { "dafgda", _wrap_dafgda, METH_VARARGS, "dafgda(SpiceInt handle, SpiceInt begin, SpiceInt end)"},
	 { "dafgn", _wrap_dafgn, METH_NOARGS, "dafgn()"},
	 { "dafgs", _wrap_dafgs, METH_NOARGS, "dafgs()"},
	 { "daffna", _wrap_daffna, METH_NOARGS, "daffna()"},
	 { "dafopr", _wrap_dafopr, METH_O, "dafopr(ConstSpiceChar * CONST_STRING)"},
	 { "dafus", _wrap_dafus, METH_VARARGS, "dafus(ConstSpiceDouble [DAFSIZE] sum, SpiceInt nd, SpiceInt ni)"},
	 { "dcyldr", _wrap_dcyldr, METH_VARARGS, "dcyldr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"},
	 { "dcyldr_vector", _wrap_dcyldr_vector, METH_VARARGS, "dcyldr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "deltet", _wrap_deltet, METH_VARARGS, "deltet(SpiceDouble epoch, ConstSpiceChar * CONST_STRING)"},
	 { "deltet_vector", _wrap_deltet_vector, METH_VARARGS, "deltet_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1)"},
	 { "det", _wrap_det, METH_O, "det(ConstSpiceDouble [3][3] m1) -> SpiceDouble"},
	 { "det_vector", _wrap_det_vector, METH_O, "det_vector(ConstSpiceDouble * in31)"},
	 { "dgeodr", _wrap_dgeodr, METH_VARARGS, "dgeodr(SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceDouble re, SpiceDouble f)"},
	 { "dgeodr_vector", _wrap_dgeodr_vector, METH_VARARGS, "dgeodr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "diags2", _wrap_diags2, METH_O, "diags2(ConstSpiceDouble [2][2] symmat)"},
	 { "diags2_vector", _wrap_diags2_vector, METH_O, "diags2_vector(ConstSpiceDouble * in31)"},
	 { "dlatdr", _wrap_dlatdr, METH_VARARGS, "dlatdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"},
	 { "dlatdr_vector", _wrap_dlatdr_vector, METH_VARARGS, "dlatdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "dpgrdr", _wrap_dpgrdr, METH_VARARGS, "dpgrdr(ConstSpiceChar * CONST_STRING, SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceDouble re, SpiceDouble f)"},
	 { "dpgrdr_vector", _wrap_dpgrdr_vector, METH_VARARGS, "dpgrdr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "dpmax", _wrap_dpmax, METH_NOARGS, "dpmax() -> SpiceDouble"},
	 { "dpmin", _wrap_dpmin, METH_NOARGS, "dpmin() -> SpiceDouble"},
	 { "dpr", _wrap_dpr, METH_NOARGS, "dpr() -> SpiceDouble"},
	 { "drdcyl", _wrap_drdcyl, METH_VARARGS, "drdcyl(SpiceDouble r, SpiceDouble lon, SpiceDouble z)"},
	 { "drdcyl_vector", _wrap_drdcyl_vector, METH_VARARGS, "drdcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "drdgeo", _wrap_drdgeo, METH_VARARGS, "drdgeo(SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"},
	 { "drdgeo_vector", _wrap_drdgeo_vector, METH_VARARGS, "drdgeo_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "drdlat", _wrap_drdlat, METH_VARARGS, "drdlat(SpiceDouble r, SpiceDouble lon, SpiceDouble lat)"},
	 { "drdlat_vector", _wrap_drdlat_vector, METH_VARARGS, "drdlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "drdpgr", _wrap_drdpgr, METH_VARARGS, "drdpgr(ConstSpiceChar * CONST_STRING, SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"},
	 { "drdpgr_vector", _wrap_drdpgr_vector, METH_VARARGS, "drdpgr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "drdsph", _wrap_drdsph, METH_VARARGS, "drdsph(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"},
	 { "drdsph_vector", _wrap_drdsph_vector, METH_VARARGS, "drdsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "dsphdr", _wrap_dsphdr, METH_VARARGS, "dsphdr(SpiceDouble x, SpiceDouble y, SpiceDouble z)"},
	 { "dsphdr_vector", _wrap_dsphdr_vector, METH_VARARGS, "dsphdr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "dtpool", _wrap_dtpool, METH_O, "dtpool(ConstSpiceChar * CONST_STRING)"},
	 { "ducrss", _wrap_ducrss, METH_VARARGS, "ducrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"},
	 { "ducrss_vector", _wrap_ducrss_vector, METH_VARARGS, "ducrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "dvcrss", _wrap_dvcrss, METH_VARARGS, "dvcrss(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2)"},
	 { "dvcrss_vector", _wrap_dvcrss_vector, METH_VARARGS, "dvcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "dvdot", _wrap_dvdot, METH_VARARGS, "dvdot(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"},
	 { "dvdot_vector", _wrap_dvdot_vector, METH_VARARGS, "dvdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "dvhat", _wrap_dvhat, METH_O, "dvhat(ConstSpiceDouble [6] s1)"},
	 { "dvhat_vector", _wrap_dvhat_vector, METH_O, "dvhat_vector(ConstSpiceDouble * in21)"},
	 { "dvnorm", _wrap_dvnorm, METH_O, "dvnorm(ConstSpiceDouble [6] state) -> SpiceDouble"},
	 { "dvnorm_vector", _wrap_dvnorm_vector, METH_O, "dvnorm_vector(ConstSpiceDouble * in21)"},
	 { "dvpool", _wrap_dvpool, METH_O, "dvpool(ConstSpiceChar * CONST_STRING)"},
	 { "dvsep", _wrap_dvsep, METH_VARARGS, "dvsep(ConstSpiceDouble [6] s1, ConstSpiceDouble [6] s2) -> SpiceDouble"},
	 { "dvsep_vector", _wrap_dvsep_vector, METH_VARARGS, "dvsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "edlimb", _wrap_edlimb, METH_VARARGS, "edlimb(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] viewpt)"},
	 { "edlimb_vector", _wrap_edlimb_vector, METH_VARARGS, "edlimb_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"},
	 { "edterm", _wrap_edterm, METH_VARARGS, "edterm(ConstSpiceChar * trmtyp, ConstSpiceChar * source, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceInt npts)"},
	 { "el2cgv", _wrap_el2cgv, METH_O, "el2cgv(ConstSpiceDouble [NELLIPSE] ellipse)"},
	 { "el2cgv_vector", _wrap_el2cgv_vector, METH_O, "el2cgv_vector(ConstSpiceDouble * in21)"},
	 { "eqncpv", _wrap_eqncpv, METH_VARARGS, "eqncpv(SpiceDouble et, SpiceDouble epoch, ConstSpiceDouble [9] eqel, SpiceDouble rapol, SpiceDouble decpol)"},
	 { "eqncpv_vector", _wrap_eqncpv_vector, METH_VARARGS, "eqncpv_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13, ConstSpiceDouble * in14)"},
	 { "erract", _wrap_erract, METH_VARARGS, "erract(ConstSpiceChar * op, SpiceInt lenout)"},
	 { "errch", _wrap_errch, METH_VARARGS, "errch(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"},
	 { "errdev", _wrap_errdev, METH_VARARGS, "errdev(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"},
	 { "errdp", _wrap_errdp, METH_VARARGS, "errdp(ConstSpiceChar * CONST_STRING, SpiceDouble number)"},
	 { "errint", _wrap_errint, METH_VARARGS, "errint(ConstSpiceChar * CONST_STRING, SpiceInt number)"},
	 { "errprt", _wrap_errprt, METH_VARARGS, "errprt(ConstSpiceChar * CONST_STRING, SpiceInt lenout)"},
	 { "et2lst", _wrap_et2lst, METH_VARARGS, "et2lst(SpiceDouble et, SpiceInt body, SpiceDouble lon, ConstSpiceChar * type)"},
	 { "et2utc", _wrap_et2utc, METH_VARARGS, "et2utc(SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt prec)"},
	 { "etcal", _wrap_etcal, METH_O, "etcal(SpiceDouble et)"},
	 { "eul2m", _wrap_eul2m, METH_VARARGS, "eul2m(SpiceDouble angle3, SpiceDouble angle2, SpiceDouble angle1, SpiceInt axis3, SpiceInt axis2, SpiceInt axis1)"},
	 { "eul2m_vector", _wrap_eul2m_vector, METH_VARARGS, "eul2m_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceInt k1, SpiceInt k2, SpiceInt k3)"},
	 { "eul2xf", _wrap_eul2xf, METH_VARARGS, "eul2xf(ConstSpiceDouble [6] eulang, SpiceInt axisa, SpiceInt axisb, SpiceInt axisc)"},
	 { "eul2xf_vector", _wrap_eul2xf_vector, METH_VARARGS, "eul2xf_vector(ConstSpiceDouble * in21, SpiceInt k1, SpiceInt k2, SpiceInt k3)"},
	 { "expool", _wrap_expool, METH_O, "expool(ConstSpiceChar * CONST_STRING)"},
	 { "failed", _wrap_failed, METH_NOARGS, "failed() -> SpiceBoolean"},
	 { "fovray", _wrap_fovray, METH_VARARGS, "fovray(ConstSpiceChar * inst, ConstSpiceDouble [3] raydir, ConstSpiceChar * rframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble et, SpiceBoolean * visibl)"},
	 { "fovray_vector", _wrap_fovray_vector, METH_VARARGS, "fovray_vector(ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in11)"},
	 { "fovtrg", _wrap_fovtrg, METH_VARARGS, "fovtrg(ConstSpiceChar * inst, ConstSpiceChar * target, ConstSpiceChar * tshape, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble et, SpiceBoolean * visibl)"},
	 { "fovtrg_vector", _wrap_fovtrg_vector, METH_VARARGS, "fovtrg_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in11)"},
	 { "frame", _wrap_frame, METH_O, "frame(ConstSpiceDouble [3] x1)"},
	 { "frame_vector", _wrap_frame_vector, METH_O, "frame_vector(SpiceDouble * in21)"},
	 { "frinfo", _wrap_frinfo, METH_O, "frinfo(SpiceInt frcode)"},
	 { "frmchg", _wrap_frmchg, METH_VARARGS, "frmchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"},
	 { "frmchg_", _wrap_frmchg_, METH_VARARGS, "frmchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * xform)"},
	 { "frmchg_vector", _wrap_frmchg_vector, METH_VARARGS, "frmchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"},
	 { "frmnam", _wrap_frmnam, METH_O, "frmnam(SpiceInt frcode)"},
	 { "furnsh", _wrap_furnsh, METH_O, "furnsh(ConstSpiceChar * CONST_STRING)"},
	 { "gcpool", _wrap_gcpool, METH_VARARGS, "gcpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"},
	 { "gdpool", _wrap_gdpool, METH_VARARGS, "gdpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"},
	 { "georec", _wrap_georec, METH_VARARGS, "georec(SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"},
	 { "georec_vector", _wrap_georec_vector, METH_VARARGS, "georec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "getfov", _wrap_getfov, METH_O, "getfov(SpiceInt instid)"},
	 { "getmsg", _wrap_getmsg, METH_O, "getmsg(ConstSpiceChar * option)"},
	 { "gipool", _wrap_gipool, METH_VARARGS, "gipool(ConstSpiceChar * CONST_STRING, SpiceInt start)"},
	 { "gnpool", _wrap_gnpool, METH_VARARGS, "gnpool(ConstSpiceChar * CONST_STRING, SpiceInt start)"},
	 { "halfpi", _wrap_halfpi, METH_NOARGS, "halfpi() -> SpiceDouble"},
	 { "ident", _wrap_ident, METH_NOARGS, "ident()"},
	 { "illum", _wrap_illum, METH_VARARGS, "illum(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [3] spoint)"},
	 { "illum_vector", _wrap_illum_vector, METH_VARARGS, "illum_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in21)"},
	 { "illumf", _wrap_illumf, METH_VARARGS, "illumf(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] spoint)"},
	 { "illumf_vector", _wrap_illumf_vector, METH_VARARGS, "illumf_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in11, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"},
	 { "illumg", _wrap_illumg, METH_VARARGS, "illumg(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] spoint)"},
	 { "illumg_vector", _wrap_illumg_vector, METH_VARARGS, "illumg_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceDouble * in11, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"},
	 { "ilumin", _wrap_ilumin, METH_VARARGS, "ilumin(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceDouble [3] spoint)"},
	 { "ilumin_vector", _wrap_ilumin_vector, METH_VARARGS, "ilumin_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceDouble * in21)"},
	 { "inedpl", _wrap_inedpl, METH_VARARGS, "inedpl(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [NPLANE] plane)"},
	 { "inedpl_vector", _wrap_inedpl_vector, METH_VARARGS, "inedpl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"},
	 { "inelpl", _wrap_inelpl, METH_VARARGS, "inelpl(ConstSpiceDouble [NELLIPSE] ellips, ConstSpiceDouble [NPLANE] plane)"},
	 { "inelpl_vector", _wrap_inelpl_vector, METH_VARARGS, "inelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "inrypl", _wrap_inrypl, METH_VARARGS, "inrypl(ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] dir, ConstSpiceDouble [NPLANE] plane)"},
	 { "inrypl_vector", _wrap_inrypl_vector, METH_VARARGS, "inrypl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "intmax", _wrap_intmax, METH_NOARGS, "intmax() -> SpiceInt"},
	 { "intmin", _wrap_intmin, METH_NOARGS, "intmin() -> SpiceInt"},
	 { "invert", _wrap_invert, METH_O, "invert(ConstSpiceDouble [3][3] m1)"},
	 { "invert_vector", _wrap_invert_vector, METH_O, "invert_vector(ConstSpiceDouble * in31)"},
	 { "invort", _wrap_invort, METH_O, "invort(ConstSpiceDouble [3][3] m)"},
	 { "invort_vector", _wrap_invort_vector, METH_O, "invort_vector(ConstSpiceDouble * in31)"},
	 { "isrot", _wrap_isrot, METH_VARARGS, "isrot(ConstSpiceDouble [3][3] m, SpiceDouble ntol, SpiceDouble dtol) -> SpiceBoolean"},
	 { "isrot_vector", _wrap_isrot_vector, METH_VARARGS, "isrot_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "j1900", _wrap_j1900, METH_NOARGS, "j1900() -> SpiceDouble"},
	 { "j1950", _wrap_j1950, METH_NOARGS, "j1950() -> SpiceDouble"},
	 { "j2000", _wrap_j2000, METH_NOARGS, "j2000() -> SpiceDouble"},
	 { "j2100", _wrap_j2100, METH_NOARGS, "j2100() -> SpiceDouble"},
	 { "jyear", _wrap_jyear, METH_NOARGS, "jyear() -> SpiceDouble"},
	 { "kplfrm", _wrap_kplfrm, METH_O, "kplfrm(SpiceInt frmcls)"},
	 { "latcyl", _wrap_latcyl, METH_VARARGS, "latcyl(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"},
	 { "latcyl_vector", _wrap_latcyl_vector, METH_VARARGS, "latcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "latrec", _wrap_latrec, METH_VARARGS, "latrec(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"},
	 { "latrec_vector", _wrap_latrec_vector, METH_VARARGS, "latrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "latsrf", _wrap_latsrf, METH_VARARGS, "latsrf(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceDouble [][2] lonlat)"},
	 { "latsph", _wrap_latsph, METH_VARARGS, "latsph(SpiceDouble radius, SpiceDouble lon, SpiceDouble lat)"},
	 { "latsph_vector", _wrap_latsph_vector, METH_VARARGS, "latsph_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "ldpool", _wrap_ldpool, METH_O, "ldpool(ConstSpiceChar * CONST_STRING)"},
	 { "limbpt", _wrap_limbpt, METH_VARARGS, "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)"},
	 { "lspcn", _wrap_lspcn, METH_VARARGS, "lspcn(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3) -> SpiceDouble"},
	 { "lspcn_vector", _wrap_lspcn_vector, METH_VARARGS, "lspcn_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2)"},
	 { "ltime", _wrap_ltime, METH_VARARGS, "ltime(SpiceDouble etobs, SpiceInt obs, ConstSpiceChar * CONST_STRING, SpiceInt targ)"},
	 { "ltime_vector", _wrap_ltime_vector, METH_VARARGS, "ltime_vector(ConstSpiceDouble * in11, SpiceInt k1, ConstSpiceChar * str1, SpiceInt k2)"},
	 { "m2eul", _wrap_m2eul, METH_VARARGS, "m2eul(ConstSpiceDouble [3][3] r, SpiceInt axis3, SpiceInt axis2, SpiceInt axis1)"},
	 { "m2eul_vector", _wrap_m2eul_vector, METH_VARARGS, "m2eul_vector(ConstSpiceDouble * in31, SpiceInt k1, SpiceInt k2, SpiceInt k3)"},
	 { "m2q", _wrap_m2q, METH_O, "m2q(ConstSpiceDouble [3][3] r)"},
	 { "m2q_vector", _wrap_m2q_vector, METH_O, "m2q_vector(ConstSpiceDouble * in31)"},
	 { "mequ", _wrap_mequ, METH_O, "mequ(ConstSpiceDouble [3][3] m1)"},
	 { "mequ_vector", _wrap_mequ_vector, METH_O, "mequ_vector(ConstSpiceDouble * in31)"},
	 { "mequg", _wrap_mequg, METH_O, "mequg(SpiceDouble * m1)"},
	 { "my_mequg_nomalloc", _wrap_my_mequg_nomalloc, METH_VARARGS, "my_mequg_nomalloc(ConstSpiceDouble * m1, SpiceInt nr, SpiceInt nc, SpiceDouble * matrix, int * nr_out, int * nc_out)"},
	 { "mequg_vector", _wrap_mequg_vector, METH_O, "mequg_vector(ConstSpiceDouble * in31)"},
	 { "mtxm", _wrap_mtxm, METH_VARARGS, "mtxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"},
	 { "mtxm_vector", _wrap_mtxm_vector, METH_VARARGS, "mtxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mtxmg", _wrap_mtxmg, METH_VARARGS, "mtxmg(SpiceDouble * m1, SpiceDouble * m2)"},
	 { "my_mtxmg_nomalloc", _wrap_my_mtxmg_nomalloc, METH_VARARGS, "my_mtxmg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, SpiceInt * nr3, SpiceInt * nc3)"},
	 { "mtxmg_vector", _wrap_mtxmg_vector, METH_VARARGS, "mtxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mtxv", _wrap_mtxv, METH_VARARGS, "mtxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] v1)"},
	 { "mtxv_vector", _wrap_mtxv_vector, METH_VARARGS, "mtxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"},
	 { "mtxvg", _wrap_mtxvg, METH_VARARGS, "mtxvg(SpiceDouble * m1, SpiceDouble * v2)"},
	 { "my_mtxvg_nomalloc", _wrap_my_mtxvg_nomalloc, METH_VARARGS, "my_mtxvg_nomalloc(ConstSpiceDouble * m1, SpiceInt nr1, SpiceInt nc1, ConstSpiceDouble * v2, SpiceInt nr2, SpiceDouble * v3, int * nr3)"},
	 { "mtxvg_vector", _wrap_mtxvg_vector, METH_VARARGS, "mtxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"},
	 { "mxm", _wrap_mxm, METH_VARARGS, "mxm(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"},
	 { "mxm_vector", _wrap_mxm_vector, METH_VARARGS, "mxm_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mxmg", _wrap_mxmg, METH_VARARGS, "mxmg(SpiceDouble * m1, SpiceDouble * m2)"},
	 { "my_mxmg_nomalloc", _wrap_my_mxmg_nomalloc, METH_VARARGS, "my_mxmg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, SpiceInt * nr3, SpiceInt * nc3)"},
	 { "mxmg_vector", _wrap_mxmg_vector, METH_VARARGS, "mxmg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mxmt", _wrap_mxmt, METH_VARARGS, "mxmt(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3][3] m2)"},
	 { "mxmt_vector", _wrap_mxmt_vector, METH_VARARGS, "mxmt_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mxmtg", _wrap_mxmtg, METH_VARARGS, "mxmtg(SpiceDouble * m1, SpiceDouble * m2)"},
	 { "my_mxmtg_nomalloc", _wrap_my_mxmtg_nomalloc, METH_VARARGS, "my_mxmtg_nomalloc(SpiceDouble * m1, SpiceDouble * m2, SpiceDouble * m3, int * nr3, int * nc3)"},
	 { "mxmtg_vector", _wrap_mxmtg_vector, METH_VARARGS, "mxmtg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in32)"},
	 { "mxv", _wrap_mxv, METH_VARARGS, "mxv(ConstSpiceDouble [3][3] m1, ConstSpiceDouble [3] v1)"},
	 { "mxv_vector", _wrap_mxv_vector, METH_VARARGS, "mxv_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"},
	 { "mxvg", _wrap_mxvg, METH_VARARGS, "mxvg(SpiceDouble * m1, SpiceDouble * v2)"},
	 { "my_mxvg_nomalloc", _wrap_my_mxvg_nomalloc, METH_VARARGS, "my_mxvg_nomalloc(SpiceDouble * m1, SpiceDouble * v2, SpiceDouble * v3, int * nr3)"},
	 { "mxvg_vector", _wrap_mxvg_vector, METH_VARARGS, "mxvg_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"},
	 { "namfrm", _wrap_namfrm, METH_O, "namfrm(ConstSpiceChar * CONST_STRING)"},
	 { "nearpt", _wrap_nearpt, METH_VARARGS, "nearpt(ConstSpiceDouble [3] positn, SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "nearpt_vector", _wrap_nearpt_vector, METH_VARARGS, "nearpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "npedln", _wrap_npedln, METH_VARARGS, "npedln(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] linept, ConstSpiceDouble [3] linedr)"},
	 { "npedln_vector", _wrap_npedln_vector, METH_VARARGS, "npedln_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "npelpt", _wrap_npelpt, METH_VARARGS, "npelpt(ConstSpiceDouble [3] point, ConstSpiceDouble [NELLIPSE] ellips)"},
	 { "npelpt_vector", _wrap_npelpt_vector, METH_VARARGS, "npelpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "nplnpt", _wrap_nplnpt, METH_VARARGS, "nplnpt(ConstSpiceDouble [3] linpt, ConstSpiceDouble [3] lindir, ConstSpiceDouble [3] point)"},
	 { "nplnpt_vector", _wrap_nplnpt_vector, METH_VARARGS, "nplnpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "nvc2pl", _wrap_nvc2pl, METH_VARARGS, "nvc2pl(ConstSpiceDouble [3] normal, SpiceDouble constant)"},
	 { "nvc2pl_vector", _wrap_nvc2pl_vector, METH_VARARGS, "nvc2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11)"},
	 { "nvp2pl", _wrap_nvp2pl, METH_VARARGS, "nvp2pl(ConstSpiceDouble [3] normal, ConstSpiceDouble [3] point)"},
	 { "nvp2pl_vector", _wrap_nvp2pl_vector, METH_VARARGS, "nvp2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "occult", _wrap_occult, METH_VARARGS, "occult(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, SpiceDouble et)"},
	 { "occult_vector", _wrap_occult_vector, METH_VARARGS, "occult_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceChar * str8, ConstSpiceDouble * in11)"},
	 { "oscelt", _wrap_oscelt, METH_VARARGS, "oscelt(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"},
	 { "oscelt_vector", _wrap_oscelt_vector, METH_VARARGS, "oscelt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "oscltx", _wrap_oscltx, METH_VARARGS, "oscltx(ConstSpiceDouble [6] state, SpiceDouble et, SpiceDouble mu)"},
	 { "oscltx_vector", _wrap_oscltx_vector, METH_VARARGS, "oscltx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "pckcov", _wrap_pckcov, METH_VARARGS, "pckcov(ConstSpiceChar * pck, SpiceInt idcode)"},
	 { "pckfrm", _wrap_pckfrm, METH_O, "pckfrm(ConstSpiceChar * pck)"},
	 { "pcpool", _wrap_pcpool, METH_VARARGS, "pcpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"},
	 { "pdpool", _wrap_pdpool, METH_VARARGS, "pdpool(ConstSpiceChar * CONST_STRING, SpiceInt n)"},
	 { "pgrrec", _wrap_pgrrec, METH_VARARGS, "pgrrec(ConstSpiceChar * CONST_STRING, SpiceDouble lon, SpiceDouble lat, SpiceDouble alt, SpiceDouble re, SpiceDouble f)"},
	 { "pgrrec_vector", _wrap_pgrrec_vector, METH_VARARGS, "pgrrec_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in14, ConstSpiceDouble * in15)"},
	 { "phaseq", _wrap_phaseq, METH_VARARGS, "phaseq(SpiceDouble et, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5) -> SpiceDouble"},
	 { "phaseq_vector", _wrap_phaseq_vector, METH_VARARGS, "phaseq_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"},
	 { "pi", _wrap_pi, METH_NOARGS, "pi() -> SpiceDouble"},
	 { "pipool", _wrap_pipool, METH_VARARGS, "pipool(ConstSpiceChar * CONST_STRING, SpiceInt n)"},
	 { "pjelpl", _wrap_pjelpl, METH_VARARGS, "pjelpl(ConstSpiceDouble [NELLIPSE] elin, ConstSpiceDouble [NPLANE] plane)"},
	 { "pjelpl_vector", _wrap_pjelpl_vector, METH_VARARGS, "pjelpl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "pltar", _wrap_pltar, METH_VARARGS, "pltar(SpiceInt nv, SpiceInt np) -> SpiceDouble"},
	 { "pltexp", _wrap_pltexp, METH_VARARGS, "pltexp(ConstSpiceDouble [3][3] iverts, SpiceDouble delta)"},
	 { "pltexp_vector", _wrap_pltexp_vector, METH_VARARGS, "pltexp_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11)"},
	 { "pltnp", _wrap_pltnp, METH_VARARGS, "pltnp(ConstSpiceDouble [3] point, ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2, ConstSpiceDouble [3] v3)"},
	 { "pltnp_vector", _wrap_pltnp_vector, METH_VARARGS, "pltnp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23, ConstSpiceDouble * in24)"},
	 { "pltvol", _wrap_pltvol, METH_VARARGS, "pltvol(SpiceInt nv, SpiceInt np) -> SpiceDouble"},
	 { "pl2nvc", _wrap_pl2nvc, METH_O, "pl2nvc(ConstSpiceDouble [NPLANE] plane)"},
	 { "pl2nvc_vector", _wrap_pl2nvc_vector, METH_O, "pl2nvc_vector(ConstSpiceDouble * in21)"},
	 { "pl2nvp", _wrap_pl2nvp, METH_O, "pl2nvp(ConstSpiceDouble [NPLANE] plane)"},
	 { "pl2nvp_vector", _wrap_pl2nvp_vector, METH_O, "pl2nvp_vector(ConstSpiceDouble * in21)"},
	 { "pl2psv", _wrap_pl2psv, METH_O, "pl2psv(ConstSpiceDouble [NPLANE] plane)"},
	 { "pl2psv_vector", _wrap_pl2psv_vector, METH_O, "pl2psv_vector(ConstSpiceDouble * in21)"},
	 { "prop2b", _wrap_prop2b, METH_VARARGS, "prop2b(SpiceDouble gm, ConstSpiceDouble [6] pvinit, SpiceDouble dt)"},
	 { "prop2b_vector", _wrap_prop2b_vector, METH_VARARGS, "prop2b_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12)"},
	 { "psv2pl", _wrap_psv2pl, METH_VARARGS, "psv2pl(ConstSpiceDouble [3] point, ConstSpiceDouble [3] span1, ConstSpiceDouble [3] span2)"},
	 { "psv2pl_vector", _wrap_psv2pl_vector, METH_VARARGS, "psv2pl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "pxform", _wrap_pxform, METH_VARARGS, "pxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"},
	 { "pxform_vector", _wrap_pxform_vector, METH_VARARGS, "pxform_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11)"},
	 { "pxfrm2", _wrap_pxfrm2, METH_VARARGS, "pxfrm2(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble etfrom, SpiceDouble etto)"},
	 { "pxfrm2_vector", _wrap_pxfrm2_vector, METH_VARARGS, "pxfrm2_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "q2m", _wrap_q2m, METH_O, "q2m(ConstSpiceDouble [4] q)"},
	 { "q2m_vector", _wrap_q2m_vector, METH_O, "q2m_vector(ConstSpiceDouble * in21)"},
	 { "qcktrc", _wrap_qcktrc, METH_NOARGS, "qcktrc()"},
	 { "qdq2av", _wrap_qdq2av, METH_VARARGS, "qdq2av(ConstSpiceDouble [4] q, ConstSpiceDouble [4] dq)"},
	 { "qdq2av_vector", _wrap_qdq2av_vector, METH_VARARGS, "qdq2av_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "qxq", _wrap_qxq, METH_VARARGS, "qxq(ConstSpiceDouble [4] q1, ConstSpiceDouble [4] q2)"},
	 { "qxq_vector", _wrap_qxq_vector, METH_VARARGS, "qxq_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "radrec", _wrap_radrec, METH_VARARGS, "radrec(SpiceDouble range, SpiceDouble ra, SpiceDouble dec)"},
	 { "radrec_vector", _wrap_radrec_vector, METH_VARARGS, "radrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "rav2xf", _wrap_rav2xf, METH_VARARGS, "rav2xf(ConstSpiceDouble [3][3] rot, ConstSpiceDouble [3] av)"},
	 { "rav2xf_vector", _wrap_rav2xf_vector, METH_VARARGS, "rav2xf_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in21)"},
	 { "raxisa", _wrap_raxisa, METH_O, "raxisa(ConstSpiceDouble [3][3] matrix)"},
	 { "raxisa_vector", _wrap_raxisa_vector, METH_O, "raxisa_vector(ConstSpiceDouble * in31)"},
	 { "reccyl", _wrap_reccyl, METH_O, "reccyl(ConstSpiceDouble [3] rectan)"},
	 { "reccyl_vector", _wrap_reccyl_vector, METH_O, "reccyl_vector(ConstSpiceDouble * in21)"},
	 { "recgeo", _wrap_recgeo, METH_VARARGS, "recgeo(ConstSpiceDouble [3] rectan, SpiceDouble re, SpiceDouble f)"},
	 { "recgeo_vector", _wrap_recgeo_vector, METH_VARARGS, "recgeo_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "reclat", _wrap_reclat, METH_O, "reclat(ConstSpiceDouble [3] rectan)"},
	 { "reclat_vector", _wrap_reclat_vector, METH_O, "reclat_vector(ConstSpiceDouble * in21)"},
	 { "recpgr", _wrap_recpgr, METH_VARARGS, "recpgr(ConstSpiceChar * CONST_STRING, SpiceDouble [3] rectan, SpiceDouble re, SpiceDouble f)"},
	 { "recpgr_vector", _wrap_recpgr_vector, METH_VARARGS, "recpgr_vector(ConstSpiceChar * str1, SpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "recrad", _wrap_recrad, METH_O, "recrad(ConstSpiceDouble [3] rectan)"},
	 { "recrad_vector", _wrap_recrad_vector, METH_O, "recrad_vector(ConstSpiceDouble * in21)"},
	 { "recsph", _wrap_recsph, METH_O, "recsph(ConstSpiceDouble [3] rectan)"},
	 { "recsph_vector", _wrap_recsph_vector, METH_O, "recsph_vector(ConstSpiceDouble * in21)"},
	 { "refchg", _wrap_refchg, METH_VARARGS, "refchg(SpiceInt frame1, SpiceInt frame2, SpiceDouble et)"},
	 { "refchg_", _wrap_refchg_, METH_VARARGS, "refchg_(SpiceInt * frame1, SpiceInt * frame2, SpiceDouble * et, SpiceDouble * rotate)"},
	 { "refchg_vector", _wrap_refchg_vector, METH_VARARGS, "refchg_vector(SpiceInt k1, SpiceInt k2, ConstSpiceDouble * in11)"},
	 { "repmc", _wrap_repmc, METH_VARARGS, "repmc(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3)"},
	 { "repmct", _wrap_repmct, METH_VARARGS, "repmct(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"},
	 { "repmd", _wrap_repmd, METH_VARARGS, "repmd(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig)"},
	 { "repmf", _wrap_repmf, METH_VARARGS, "repmf(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble value, SpiceInt sigdig, SpiceChar format)"},
	 { "repmi", _wrap_repmi, METH_VARARGS, "repmi(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value)"},
	 { "repmot", _wrap_repmot, METH_VARARGS, "repmot(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt value, SpiceChar IN_STRING)"},
	 { "reset", _wrap_reset, METH_NOARGS, "reset()"},
	 { "rotate", _wrap_rotate, METH_VARARGS, "rotate(SpiceDouble angle, SpiceInt iaxis)"},
	 { "rotate_vector", _wrap_rotate_vector, METH_VARARGS, "rotate_vector(ConstSpiceDouble * in11, SpiceInt k1)"},
	 { "rotmat", _wrap_rotmat, METH_VARARGS, "rotmat(ConstSpiceDouble [3][3] m1, SpiceDouble angle, SpiceInt iaxis)"},
	 { "rotmat_vector", _wrap_rotmat_vector, METH_VARARGS, "rotmat_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, SpiceInt k1)"},
	 { "rotvec", _wrap_rotvec, METH_VARARGS, "rotvec(ConstSpiceDouble [3] v1, SpiceDouble angle, SpiceInt iaxis)"},
	 { "rotvec_vector", _wrap_rotvec_vector, METH_VARARGS, "rotvec_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, SpiceInt k1)"},
	 { "rpd", _wrap_rpd, METH_NOARGS, "rpd() -> SpiceDouble"},
	 { "rquad", _wrap_rquad, METH_VARARGS, "rquad(SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "rquad_vector", _wrap_rquad_vector, METH_VARARGS, "rquad_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "saelgv", _wrap_saelgv, METH_VARARGS, "saelgv(ConstSpiceDouble [3] vec1, ConstSpiceDouble [3] vec2)"},
	 { "saelgv_vector", _wrap_saelgv_vector, METH_VARARGS, "saelgv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "scdecd", _wrap_scdecd, METH_VARARGS, "scdecd(SpiceInt sc, SpiceDouble sclkdp)"},
	 { "sce2c", _wrap_sce2c, METH_VARARGS, "sce2c(SpiceInt sc, SpiceDouble et)"},
	 { "sce2c_vector", _wrap_sce2c_vector, METH_VARARGS, "sce2c_vector(SpiceInt k1, ConstSpiceDouble * in11)"},
	 { "sce2s", _wrap_sce2s, METH_VARARGS, "sce2s(SpiceInt sc, SpiceDouble et)"},
	 { "sce2t", _wrap_sce2t, METH_VARARGS, "sce2t(SpiceInt sc, SpiceDouble et)"},
	 { "sce2t_vector", _wrap_sce2t_vector, METH_VARARGS, "sce2t_vector(SpiceInt k1, ConstSpiceDouble * in11)"},
	 { "scencd", _wrap_scencd, METH_VARARGS, "scencd(SpiceInt sc, ConstSpiceChar * CONST_STRING)"},
	 { "scfmt", _wrap_scfmt, METH_VARARGS, "scfmt(SpiceInt sc, SpiceDouble ticks)"},
	 { "scpart", _wrap_scpart, METH_O, "scpart(SpiceInt sc)"},
	 { "scs2e", _wrap_scs2e, METH_VARARGS, "scs2e(SpiceInt sc, ConstSpiceChar * CONST_STRING)"},
	 { "sct2e", _wrap_sct2e, METH_VARARGS, "sct2e(SpiceInt sc, SpiceDouble sclkdp)"},
	 { "sct2e_vector", _wrap_sct2e_vector, METH_VARARGS, "sct2e_vector(SpiceInt k1, ConstSpiceDouble * in11)"},
	 { "sctiks", _wrap_sctiks, METH_VARARGS, "sctiks(SpiceInt sc, ConstSpiceChar * CONST_STRING)"},
	 { "setmsg", _wrap_setmsg, METH_O, "setmsg(ConstSpiceChar * message)"},
	 { "sigerr", _wrap_sigerr, METH_O, "sigerr(ConstSpiceChar * CONST_STRING)"},
	 { "sincpt", _wrap_sincpt, METH_VARARGS, "sincpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceDouble [3] dvec)"},
	 { "sincpt_vector", _wrap_sincpt_vector, METH_VARARGS, "sincpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceDouble * in21)"},
	 { "spd", _wrap_spd, METH_NOARGS, "spd() -> SpiceDouble"},
	 { "sphcyl", _wrap_sphcyl, METH_VARARGS, "sphcyl(SpiceDouble radius, SpiceDouble colat, SpiceDouble lon)"},
	 { "sphcyl_vector", _wrap_sphcyl_vector, METH_VARARGS, "sphcyl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "sphlat", _wrap_sphlat, METH_VARARGS, "sphlat(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"},
	 { "sphlat_vector", _wrap_sphlat_vector, METH_VARARGS, "sphlat_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "sphrec", _wrap_sphrec, METH_VARARGS, "sphrec(SpiceDouble r, SpiceDouble colat, SpiceDouble lon)"},
	 { "sphrec_vector", _wrap_sphrec_vector, METH_VARARGS, "sphrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "spkacs", _wrap_spkacs, METH_VARARGS, "spkacs(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"},
	 { "spkacs_vector", _wrap_spkacs_vector, METH_VARARGS, "spkacs_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"},
	 { "spkapo", _wrap_spkapo, METH_VARARGS, "spkapo(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceDouble [6] sobs, ConstSpiceChar * arg5)"},
	 { "spkapo_vector", _wrap_spkapo_vector, METH_VARARGS, "spkapo_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2)"},
	 { "spkapp", _wrap_spkapp, METH_VARARGS, "spkapp(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceDouble [6] sobs, ConstSpiceChar * arg5)"},
	 { "spkapp_vector", _wrap_spkapp_vector, METH_VARARGS, "spkapp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceDouble * in21, ConstSpiceChar * str2)"},
	 { "spkaps", _wrap_spkaps, METH_VARARGS, "spkaps(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [6] stobs, ConstSpiceDouble [3] accobs)"},
	 { "spkaps_vector", _wrap_spkaps_vector, METH_VARARGS, "spkaps_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "spkcov", _wrap_spkcov, METH_VARARGS, "spkcov(ConstSpiceChar * spk, SpiceInt idcode)"},
	 { "spkez", _wrap_spkez, METH_VARARGS, "spkez(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"},
	 { "spkez_vector", _wrap_spkez_vector, METH_VARARGS, "spkez_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"},
	 { "spkezp", _wrap_spkezp, METH_VARARGS, "spkezp(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceInt obs)"},
	 { "spkezp_vector", _wrap_spkezp_vector, METH_VARARGS, "spkezp_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, SpiceInt k2)"},
	 { "spkezr", _wrap_spkezr, METH_VARARGS, "spkezr(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"},
	 { "spkezr_vector", _wrap_spkezr_vector, METH_VARARGS, "spkezr_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"},
	 { "spkgeo", _wrap_spkgeo, METH_VARARGS, "spkgeo(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt obs)"},
	 { "spkgeo_vector", _wrap_spkgeo_vector, METH_VARARGS, "spkgeo_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, SpiceInt k2)"},
	 { "spkgps", _wrap_spkgps, METH_VARARGS, "spkgps(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING, SpiceInt obs)"},
	 { "spkgps_vector", _wrap_spkgps_vector, METH_VARARGS, "spkgps_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, SpiceInt k2)"},
	 { "spkltc", _wrap_spkltc, METH_VARARGS, "spkltc(SpiceInt targ, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceDouble [6] stobs)"},
	 { "spkltc_vector", _wrap_spkltc_vector, METH_VARARGS, "spkltc_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in21)"},
	 { "spkobj", _wrap_spkobj, METH_O, "spkobj(ConstSpiceChar * spk)"},
	 { "spkpos", _wrap_spkpos, METH_VARARGS, "spkpos(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"},
	 { "spkpos_vector", _wrap_spkpos_vector, METH_VARARGS, "spkpos_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4)"},
	 { "spkssb", _wrap_spkssb, METH_VARARGS, "spkssb(SpiceInt targ, SpiceDouble et, ConstSpiceChar * CONST_STRING)"},
	 { "spkssb_vector", _wrap_spkssb_vector, METH_VARARGS, "spkssb_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceChar * str1)"},
	 { "srfc2s", _wrap_srfc2s, METH_VARARGS, "srfc2s(SpiceInt code, SpiceInt bodyid)"},
	 { "srfcss", _wrap_srfcss, METH_VARARGS, "srfcss(SpiceInt code, ConstSpiceChar * CONST_STRING)"},
	 { "srfnrm", _wrap_srfnrm, METH_VARARGS, "srfnrm(ConstSpiceChar * method, ConstSpiceChar * target, SpiceDouble et, ConstSpiceChar * fixref, SpiceInt npts)"},
	 { "srfrec", _wrap_srfrec, METH_VARARGS, "srfrec(SpiceInt body, SpiceDouble lon, SpiceDouble lat)"},
	 { "srfrec_vector", _wrap_srfrec_vector, METH_VARARGS, "srfrec_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "srfs2c", _wrap_srfs2c, METH_VARARGS, "srfs2c(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"},
	 { "srfscc", _wrap_srfscc, METH_VARARGS, "srfscc(ConstSpiceChar * CONST_STRING, SpiceInt bodyid)"},
	 { "srfxpt", _wrap_srfxpt, METH_VARARGS, "srfxpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceDouble [3] dvec)"},
	 { "srfxpt_vector", _wrap_srfxpt_vector, METH_VARARGS, "srfxpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceDouble * in21)"},
	 { "stcf01", _wrap_stcf01, METH_VARARGS, "stcf01(ConstSpiceChar * catnam, SpiceDouble westra, SpiceDouble eastra, SpiceDouble sthdec, SpiceDouble nthdec)"},
	 { "stcg01", _wrap_stcg01, METH_O, "stcg01(SpiceInt index)"},
	 { "stcl01", _wrap_stcl01, METH_O, "stcl01(ConstSpiceChar * catfnm)"},
	 { "stelab", _wrap_stelab, METH_VARARGS, "stelab(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"},
	 { "stelab_vector", _wrap_stelab_vector, METH_VARARGS, "stelab_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "stlabx", _wrap_stlabx, METH_VARARGS, "stlabx(ConstSpiceDouble [3] pobj, ConstSpiceDouble [3] vobs)"},
	 { "stlabx_vector", _wrap_stlabx_vector, METH_VARARGS, "stlabx_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "stpool", _wrap_stpool, METH_VARARGS, "stpool(ConstSpiceChar * item, SpiceInt nth, ConstSpiceChar * contin)"},
	 { "str2et", _wrap_str2et, METH_O, "str2et(ConstSpiceChar * CONST_STRING)"},
	 { "subpnt", _wrap_subpnt, METH_VARARGS, "subpnt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6)"},
	 { "subpnt_vector", _wrap_subpnt_vector, METH_VARARGS, "subpnt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5)"},
	 { "subpt", _wrap_subpt, METH_VARARGS, "subpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"},
	 { "subpt_vector", _wrap_subpt_vector, METH_VARARGS, "subpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4)"},
	 { "subslr", _wrap_subslr, METH_VARARGS, "subslr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6)"},
	 { "subslr_vector", _wrap_subslr_vector, METH_VARARGS, "subslr_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5)"},
	 { "subsol", _wrap_subsol, METH_VARARGS, "subsol(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5)"},
	 { "subsol_vector", _wrap_subsol_vector, METH_VARARGS, "subsol_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4)"},
	 { "surfnm", _wrap_surfnm, METH_VARARGS, "surfnm(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] point)"},
	 { "surfpt", _wrap_surfpt, METH_VARARGS, "surfpt(ConstSpiceDouble [3] positn, ConstSpiceDouble [3] u, SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "surfpt_vector", _wrap_surfpt_vector, METH_VARARGS, "surfpt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "surfpv", _wrap_surfpv, METH_VARARGS, "surfpv(ConstSpiceDouble [6] stvrtx, ConstSpiceDouble [6] stdir, SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "surfpv_vector", _wrap_surfpv_vector, METH_VARARGS, "surfpv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "sxform", _wrap_sxform, METH_VARARGS, "sxform(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et)"},
	 { "sxform_vector", _wrap_sxform_vector, METH_VARARGS, "sxform_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11)"},
	 { "termpt", _wrap_termpt, METH_VARARGS, "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)"},
	 { "timdef", _wrap_timdef, METH_VARARGS, "timdef(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt lenout)"},
	 { "timout", _wrap_timout, METH_VARARGS, "timout(SpiceDouble et, ConstSpiceChar * CONST_STRING)"},
	 { "tipbod", _wrap_tipbod, METH_VARARGS, "tipbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"},
	 { "tipbod_vector", _wrap_tipbod_vector, METH_VARARGS, "tipbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"},
	 { "tisbod", _wrap_tisbod, METH_VARARGS, "tisbod(ConstSpiceChar * CONST_STRING, SpiceInt body, SpiceDouble et)"},
	 { "tisbod_vector", _wrap_tisbod_vector, METH_VARARGS, "tisbod_vector(ConstSpiceChar * str1, SpiceInt k1, ConstSpiceDouble * in11)"},
	 { "tkvrsn", _wrap_tkvrsn, METH_O, "tkvrsn(ConstSpiceChar * CONST_STRING) -> SpiceChar *"},
	 { "tparse", _wrap_tparse, METH_O, "tparse(ConstSpiceChar * string)"},
	 { "tpictr", _wrap_tpictr, METH_O, "tpictr(ConstSpiceChar * sample)"},
	 { "trace", _wrap_trace, METH_O, "trace(ConstSpiceDouble [3][3] matrix) -> SpiceDouble"},
	 { "trace_vector", _wrap_trace_vector, METH_O, "trace_vector(ConstSpiceDouble * in31)"},
	 { "trcoff", _wrap_trcoff, METH_NOARGS, "trcoff()"},
	 { "trcdep", _wrap_trcdep, METH_NOARGS, "trcdep()"},
	 { "trcnam", _wrap_trcnam, METH_O, "trcnam(SpiceInt index)"},
	 { "tsetyr", _wrap_tsetyr, METH_O, "tsetyr(SpiceInt year)"},
	 { "twopi", _wrap_twopi, METH_NOARGS, "twopi() -> SpiceDouble"},
	 { "twovec", _wrap_twovec, METH_VARARGS, "twovec(ConstSpiceDouble [3] axdef, SpiceInt indexa, ConstSpiceDouble [3] plndef, SpiceInt indexp)"},
	 { "twovec_vector", _wrap_twovec_vector, METH_VARARGS, "twovec_vector(ConstSpiceDouble * in21, SpiceInt k1, ConstSpiceDouble * in22, SpiceInt k2)"},
	 { "tyear", _wrap_tyear, METH_NOARGS, "tyear() -> SpiceDouble"},
	 { "ucrss", _wrap_ucrss, METH_VARARGS, "ucrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"},
	 { "ucrss_vector", _wrap_ucrss_vector, METH_VARARGS, "ucrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "unitim", _wrap_unitim, METH_VARARGS, "unitim(SpiceDouble epoch, ConstSpiceChar * arg2, ConstSpiceChar * arg3) -> SpiceDouble"},
	 { "unitim_vector", _wrap_unitim_vector, METH_VARARGS, "unitim_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2)"},
	 { "unload", _wrap_unload, METH_O, "unload(ConstSpiceChar * CONST_STRING)"},
	 { "unorm", _wrap_unorm, METH_O, "unorm(ConstSpiceDouble [3] v1)"},
	 { "unorm_vector", _wrap_unorm_vector, METH_O, "unorm_vector(ConstSpiceDouble * in21)"},
	 { "unormg", _wrap_unormg, METH_O, "unormg(ConstSpiceDouble * v1)"},
	 { "my_unormg_nomalloc", _wrap_my_unormg_nomalloc, METH_VARARGS, "my_unormg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * vector, int * nd2)"},
	 { "unormg_vector", _wrap_unormg_vector, METH_O, "unormg_vector(ConstSpiceDouble * in21)"},
	 { "utc2et", _wrap_utc2et, METH_O, "utc2et(ConstSpiceChar * CONST_STRING)"},
	 { "vadd", _wrap_vadd, METH_VARARGS, "vadd(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"},
	 { "vadd_vector", _wrap_vadd_vector, METH_VARARGS, "vadd_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vaddg", _wrap_vaddg, METH_VARARGS, "vaddg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"},
	 { "my_vaddg_nomalloc", _wrap_my_vaddg_nomalloc, METH_VARARGS, "my_vaddg_nomalloc(ConstSpiceDouble * v1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"},
	 { "vaddg_vector", _wrap_vaddg_vector, METH_VARARGS, "vaddg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vcrss", _wrap_vcrss, METH_VARARGS, "vcrss(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"},
	 { "vcrss_vector", _wrap_vcrss_vector, METH_VARARGS, "vcrss_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vdist", _wrap_vdist, METH_VARARGS, "vdist(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"},
	 { "vdist_vector", _wrap_vdist_vector, METH_VARARGS, "vdist_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vdistg", _wrap_vdistg, METH_VARARGS, "vdistg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"},
	 { "vdistg_vector", _wrap_vdistg_vector, METH_VARARGS, "vdistg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vdot", _wrap_vdot, METH_VARARGS, "vdot(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"},
	 { "vdot_vector", _wrap_vdot_vector, METH_VARARGS, "vdot_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vdotg", _wrap_vdotg, METH_VARARGS, "vdotg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"},
	 { "vdotg_vector", _wrap_vdotg_vector, METH_VARARGS, "vdotg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vequ", _wrap_vequ, METH_O, "vequ(ConstSpiceDouble [3] v1)"},
	 { "vequ_vector", _wrap_vequ_vector, METH_O, "vequ_vector(ConstSpiceDouble * in21)"},
	 { "vequg", _wrap_vequg, METH_O, "vequg(ConstSpiceDouble * v1)"},
	 { "my_vequg_nomalloc", _wrap_my_vequg_nomalloc, METH_VARARGS, "my_vequg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"},
	 { "vequg_vector", _wrap_vequg_vector, METH_O, "vequg_vector(ConstSpiceDouble * in21)"},
	 { "vhat", _wrap_vhat, METH_O, "vhat(ConstSpiceDouble [3] v1)"},
	 { "vhat_vector", _wrap_vhat_vector, METH_O, "vhat_vector(ConstSpiceDouble * in21)"},
	 { "vhatg", _wrap_vhatg, METH_O, "vhatg(ConstSpiceDouble * v1)"},
	 { "my_vhatg_nomalloc", _wrap_my_vhatg_nomalloc, METH_VARARGS, "my_vhatg_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"},
	 { "vhatg_vector", _wrap_vhatg_vector, METH_O, "vhatg_vector(ConstSpiceDouble * in21)"},
	 { "vlcom3", _wrap_vlcom3, METH_VARARGS, "vlcom3(SpiceDouble a, ConstSpiceDouble [3] v1, SpiceDouble b, ConstSpiceDouble [3] v2, SpiceDouble c, ConstSpiceDouble [3] v3)"},
	 { "vlcom3_vector", _wrap_vlcom3_vector, METH_VARARGS, "vlcom3_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22, ConstSpiceDouble * in13, ConstSpiceDouble * in23)"},
	 { "vlcom", _wrap_vlcom, METH_VARARGS, "vlcom(SpiceDouble a, ConstSpiceDouble [3] v1, SpiceDouble b, ConstSpiceDouble [3] v2)"},
	 { "vlcom_vector", _wrap_vlcom_vector, METH_VARARGS, "vlcom_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"},
	 { "vlcomg", _wrap_vlcomg, METH_VARARGS, "vlcomg(SpiceDouble a, ConstSpiceDouble * v1, SpiceDouble b, ConstSpiceDouble * v2)"},
	 { "my_vlcomg_nomalloc", _wrap_my_vlcomg_nomalloc, METH_VARARGS, "my_vlcomg_nomalloc(SpiceDouble a, ConstSpiceDouble * v1, SpiceDouble b, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"},
	 { "vlcomg_vector", _wrap_vlcomg_vector, METH_VARARGS, "vlcomg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceDouble * in22)"},
	 { "vminug", _wrap_vminug, METH_O, "vminug(ConstSpiceDouble * v1)"},
	 { "my_vminug_nomalloc", _wrap_my_vminug_nomalloc, METH_VARARGS, "my_vminug_nomalloc(ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"},
	 { "vminug_vector", _wrap_vminug_vector, METH_O, "vminug_vector(ConstSpiceDouble * in21)"},
	 { "vminus", _wrap_vminus, METH_O, "vminus(ConstSpiceDouble [3] v1)"},
	 { "vminus_vector", _wrap_vminus_vector, METH_O, "vminus_vector(ConstSpiceDouble * in21)"},
	 { "vnorm", _wrap_vnorm, METH_O, "vnorm(ConstSpiceDouble [3] v1) -> SpiceDouble"},
	 { "vnorm_vector", _wrap_vnorm_vector, METH_O, "vnorm_vector(ConstSpiceDouble * in21)"},
	 { "vnormg", _wrap_vnormg, METH_O, "vnormg(ConstSpiceDouble * v1) -> SpiceDouble"},
	 { "vnormg_vector", _wrap_vnormg_vector, METH_O, "vnormg_vector(ConstSpiceDouble * in21)"},
	 { "vpack", _wrap_vpack, METH_VARARGS, "vpack(SpiceDouble x, SpiceDouble y, SpiceDouble z)"},
	 { "vpack_vector", _wrap_vpack_vector, METH_VARARGS, "vpack_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "vperp", _wrap_vperp, METH_VARARGS, "vperp(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"},
	 { "vperp_vector", _wrap_vperp_vector, METH_VARARGS, "vperp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vprjp", _wrap_vprjp, METH_VARARGS, "vprjp(ConstSpiceDouble [3] v1, ConstSpiceDouble [NPLANE] plane)"},
	 { "vprjp_vector", _wrap_vprjp_vector, METH_VARARGS, "vprjp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vprjpi", _wrap_vprjpi, METH_VARARGS, "vprjpi(ConstSpiceDouble [3] v1, ConstSpiceDouble [NPLANE] projpl, ConstSpiceDouble [NPLANE] invpl)"},
	 { "vprjpi_vector", _wrap_vprjpi_vector, METH_VARARGS, "vprjpi_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "vproj", _wrap_vproj, METH_VARARGS, "vproj(ConstSpiceDouble [3] a, ConstSpiceDouble [3] b)"},
	 { "vproj_vector", _wrap_vproj_vector, METH_VARARGS, "vproj_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vrel", _wrap_vrel, METH_VARARGS, "vrel(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"},
	 { "vrel_vector", _wrap_vrel_vector, METH_VARARGS, "vrel_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vrelg", _wrap_vrelg, METH_VARARGS, "vrelg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"},
	 { "vrelg_vector", _wrap_vrelg_vector, METH_VARARGS, "vrelg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vrotv", _wrap_vrotv, METH_VARARGS, "vrotv(ConstSpiceDouble [3] v, ConstSpiceDouble [3] axis, SpiceDouble theta)"},
	 { "vrotv_vector", _wrap_vrotv_vector, METH_VARARGS, "vrotv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "vscl", _wrap_vscl, METH_VARARGS, "vscl(SpiceDouble s, ConstSpiceDouble [3] v1)"},
	 { "vscl_vector", _wrap_vscl_vector, METH_VARARGS, "vscl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"},
	 { "vsclg", _wrap_vsclg, METH_VARARGS, "vsclg(SpiceDouble s, ConstSpiceDouble * v1)"},
	 { "my_vsclg_nomalloc", _wrap_my_vsclg_nomalloc, METH_VARARGS, "my_vsclg_nomalloc(SpiceDouble s, ConstSpiceDouble * v1, SpiceDouble * v2, int * nd2)"},
	 { "vsclg_vector", _wrap_vsclg_vector, METH_VARARGS, "vsclg_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"},
	 { "vsep", _wrap_vsep, METH_VARARGS, "vsep(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2) -> SpiceDouble"},
	 { "vsep_vector", _wrap_vsep_vector, METH_VARARGS, "vsep_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vsepg", _wrap_vsepg, METH_VARARGS, "vsepg(ConstSpiceDouble * v1, ConstSpiceDouble * v2) -> SpiceDouble"},
	 { "vsepg_vector", _wrap_vsepg_vector, METH_VARARGS, "vsepg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vsub", _wrap_vsub, METH_VARARGS, "vsub(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2)"},
	 { "vsub_vector", _wrap_vsub_vector, METH_VARARGS, "vsub_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vsubg", _wrap_vsubg, METH_VARARGS, "vsubg(ConstSpiceDouble * v1, ConstSpiceDouble * v2)"},
	 { "my_vsubg_nomalloc", _wrap_my_vsubg_nomalloc, METH_VARARGS, "my_vsubg_nomalloc(ConstSpiceDouble * v1, ConstSpiceDouble * v2, SpiceDouble * v3, int * nd3)"},
	 { "vsubg_vector", _wrap_vsubg_vector, METH_VARARGS, "vsubg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "vtmv", _wrap_vtmv, METH_VARARGS, "vtmv(ConstSpiceDouble [3] v1, ConstSpiceDouble [3][3] matrix, ConstSpiceDouble [3] v2) -> SpiceDouble"},
	 { "vtmv_vector", _wrap_vtmv_vector, METH_VARARGS, "vtmv_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"},
	 { "vtmvg", _wrap_vtmvg, METH_VARARGS, "vtmvg(SpiceDouble * v1, SpiceDouble * matrix, SpiceDouble * v2) -> SpiceDouble"},
	 { "vtmvg_vector", _wrap_vtmvg_vector, METH_VARARGS, "vtmvg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in22)"},
	 { "vupack", _wrap_vupack, METH_O, "vupack(ConstSpiceDouble [3] v)"},
	 { "vupack_vector", _wrap_vupack_vector, METH_O, "vupack_vector(ConstSpiceDouble * in21)"},
	 { "vzero", _wrap_vzero, METH_O, "vzero(ConstSpiceDouble [3] v) -> SpiceBoolean"},
	 { "vzero_vector", _wrap_vzero_vector, METH_O, "vzero_vector(ConstSpiceDouble * in21)"},
	 { "vzerog", _wrap_vzerog, METH_O, "vzerog(ConstSpiceDouble * v) -> SpiceBoolean"},
	 { "vzerog_vector", _wrap_vzerog_vector, METH_O, "vzerog_vector(ConstSpiceDouble * in21)"},
	 { "xf2eul", _wrap_xf2eul, METH_VARARGS, "xf2eul(ConstSpiceDouble [6][6] xform, SpiceInt axisa, SpiceInt axisb, SpiceInt axisc)"},
	 { "xf2eul_vector", _wrap_xf2eul_vector, METH_VARARGS, "xf2eul_vector(ConstSpiceDouble * in31, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "xf2rav", _wrap_xf2rav, METH_O, "xf2rav(ConstSpiceDouble [6][6] xform)"},
	 { "xf2rav_vector", _wrap_xf2rav_vector, METH_O, "xf2rav_vector(ConstSpiceDouble * in31)"},
	 { "xfmsta", _wrap_xfmsta, METH_VARARGS, "xfmsta(ConstSpiceDouble [6] state1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4)"},
	 { "xfmsta_vector", _wrap_xfmsta_vector, METH_VARARGS, "xfmsta_vector(ConstSpiceDouble * in21, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3)"},
	 { "xpose6", _wrap_xpose6, METH_O, "xpose6(ConstSpiceDouble [6][6] m1)"},
	 { "xpose6_vector", _wrap_xpose6_vector, METH_O, "xpose6_vector(ConstSpiceDouble * in31)"},
	 { "xpose", _wrap_xpose, METH_O, "xpose(ConstSpiceDouble [3][3] m1)"},
	 { "xpose_vector", _wrap_xpose_vector, METH_O, "xpose_vector(ConstSpiceDouble * in31)"},
	 { "xposeg", _wrap_xposeg, METH_O, "xposeg(ConstSpiceDouble * matrix)"},
	 { "my_xposeg_nomalloc", _wrap_my_xposeg_nomalloc, METH_VARARGS, "my_xposeg_nomalloc(ConstSpiceDouble * matrix, SpiceDouble * xposem, int * nrow1, int * nc1)"},
	 { "xposeg_vector", _wrap_xposeg_vector, METH_O, "xposeg_vector(ConstSpiceDouble * in31)"},
	 { "azlcpo", _wrap_azlcpo, METH_VARARGS, "azlcpo(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, SpiceBoolean azccw, SpiceBoolean elplsz, ConstSpiceDouble [3] obspos, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"},
	 { "azlcpo_vector", _wrap_azlcpo_vector, METH_VARARGS, "azlcpo_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, SpiceBoolean b1, SpiceBoolean b2, ConstSpiceDouble * in21, ConstSpiceChar * str4, ConstSpiceChar * str5)"},
	 { "azlrec", _wrap_azlrec, METH_VARARGS, "azlrec(SpiceDouble range, SpiceDouble az, SpiceDouble el, SpiceBoolean azccw, SpiceBoolean elplsz)"},
	 { "azlrec_vector", _wrap_azlrec_vector, METH_VARARGS, "azlrec_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"},
	 { "badkpv", _wrap_badkpv, METH_VARARGS, "badkpv(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt size, SpiceInt divby, SpiceChar IN_STRING)"},
	 { "brcktd", _wrap_brcktd, METH_VARARGS, "brcktd(SpiceDouble number, SpiceDouble end1, SpiceDouble end2) -> SpiceDouble"},
	 { "brcktd_vector", _wrap_brcktd_vector, METH_VARARGS, "brcktd_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "brckti", _wrap_brckti, METH_VARARGS, "brckti(SpiceInt number, SpiceInt end1, SpiceInt end2) -> SpiceInt"},
	 { "bschoc", _wrap_bschoc, METH_VARARGS, "bschoc(ConstSpiceChar * CONST_STRING, SpiceInt ndim, ConstSpiceInt * order) -> SpiceInt"},
	 { "bschoi", _wrap_bschoi, METH_VARARGS, "bschoi(SpiceInt value, SpiceInt ndim, ConstSpiceInt * order) -> SpiceInt"},
	 { "bsrchc", _wrap_bsrchc, METH_VARARGS, "bsrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"},
	 { "bsrchd", _wrap_bsrchd, METH_VARARGS, "bsrchd(SpiceDouble value, SpiceInt ndim) -> SpiceInt"},
	 { "my_bsrchd_vector", _wrap_my_bsrchd_vector, METH_VARARGS, "my_bsrchd_vector(SpiceDouble value, ConstSpiceDouble * array, SpiceInt ndim) -> SpiceInt"},
	 { "bsrchd_vector", _wrap_bsrchd_vector, METH_VARARGS, "bsrchd_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21)"},
	 { "bsrchi", _wrap_bsrchi, METH_VARARGS, "bsrchi(SpiceInt value, SpiceInt ndim) -> SpiceInt"},
	 { "chbder", _wrap_chbder, METH_VARARGS, "chbder(ConstSpiceDouble * cp, SpiceDouble [2] x2s, SpiceDouble x, SpiceInt nderiv)"},
	 { "chbder_vector", _wrap_chbder_vector, METH_VARARGS, "chbder_vector(ConstSpiceDouble * in21, SpiceDouble [2] x2s, ConstSpiceDouble * in12, SpiceInt nderiv)"},
	 { "chbigr", _wrap_chbigr, METH_VARARGS, "chbigr(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"},
	 { "chbigr_vector", _wrap_chbigr_vector, METH_VARARGS, "chbigr_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "chbint", _wrap_chbint, METH_VARARGS, "chbint(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"},
	 { "chbint_vector", _wrap_chbint_vector, METH_VARARGS, "chbint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "chbval", _wrap_chbval, METH_VARARGS, "chbval(ConstSpiceDouble * cp, ConstSpiceDouble [2] x2s, SpiceDouble x)"},
	 { "chbval_vector", _wrap_chbval_vector, METH_VARARGS, "chbval_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "ckcls", _wrap_ckcls, METH_O, "ckcls(SpiceInt handle)"},
	 { "ckfrot", _wrap_ckfrot, METH_VARARGS, "ckfrot(SpiceInt inst, SpiceDouble et)"},
	 { "ckfrot_vector", _wrap_ckfrot_vector, METH_VARARGS, "ckfrot_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in31)"},
	 { "ckfxfm", _wrap_ckfxfm, METH_VARARGS, "ckfxfm(SpiceInt inst, SpiceDouble et)"},
	 { "ckfxfm_vector", _wrap_ckfxfm_vector, METH_VARARGS, "ckfxfm_vector(SpiceInt k1, ConstSpiceDouble * in11, ConstSpiceDouble * in31)"},
	 { "ckgr02", _wrap_ckgr02, METH_VARARGS, "ckgr02(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceInt recno)"},
	 { "ckgr03", _wrap_ckgr03, METH_VARARGS, "ckgr03(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceInt recno)"},
	 { "cklpf", _wrap_cklpf, METH_O, "cklpf(ConstSpiceChar * CONST_STRING)"},
	 { "ckmeta", _wrap_ckmeta, METH_VARARGS, "ckmeta(SpiceInt ckid, ConstSpiceChar * CONST_STRING)"},
	 { "cknr02", _wrap_cknr02, METH_VARARGS, "cknr02(SpiceInt handle, ConstSpiceDouble [5] descr)"},
	 { "cknr03", _wrap_cknr03, METH_VARARGS, "cknr03(SpiceInt handle, ConstSpiceDouble [5] descr)"},
	 { "ckopn", _wrap_ckopn, METH_VARARGS, "ckopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"},
	 { "ckupf", _wrap_ckupf, METH_O, "ckupf(SpiceInt handle)"},
	 { "ckw01", _wrap_ckw01, METH_VARARGS, "ckw01(SpiceInt handle, SpiceDouble begtim, SpiceDouble endtim, SpiceInt inst, ConstSpiceChar * arg5, SpiceBoolean avflag, ConstSpiceChar * arg7, SpiceInt nrec, ConstSpiceDouble [][4] quats, ConstSpiceDouble [][3] avvs)"},
	 { "ckw02", _wrap_ckw02, METH_VARARGS, "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)"},
	 { "ckw03", _wrap_ckw03, METH_VARARGS, "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)"},
	 { "ckw05", _wrap_ckw05, METH_VARARGS, "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)"},
	 { "cmprss", _wrap_cmprss, METH_VARARGS, "cmprss(SpiceChar delim, SpiceInt n, ConstSpiceChar * CONST_STRING)"},
	 { "cpos", _wrap_cpos, METH_VARARGS, "cpos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "cposr", _wrap_cposr, METH_VARARGS, "cposr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "cvpool", _wrap_cvpool, METH_O, "cvpool(ConstSpiceChar * CONST_STRING)"},
	 { "dafac", _wrap_dafac, METH_VARARGS, "dafac(SpiceInt handle, SpiceInt n)"},
	 { "dafbbs", _wrap_dafbbs, METH_O, "dafbbs(SpiceInt handle)"},
	 { "dafcs", _wrap_dafcs, METH_O, "dafcs(SpiceInt handle)"},
	 { "dafdc", _wrap_dafdc, METH_O, "dafdc(SpiceInt handle)"},
	 { "dafec", _wrap_dafec, METH_O, "dafec(SpiceInt handle)"},
	 { "daffpa", _wrap_daffpa, METH_NOARGS, "daffpa()"},
	 { "dafgh", _wrap_dafgh, METH_NOARGS, "dafgh()"},
	 { "dafgsr", _wrap_dafgsr, METH_VARARGS, "dafgsr(SpiceInt handle, SpiceInt recno, SpiceInt begin, SpiceInt end)"},
	 { "dafhsf", _wrap_dafhsf, METH_O, "dafhsf(SpiceInt handle)"},
	 { "dafopw", _wrap_dafopw, METH_O, "dafopw(ConstSpiceChar * CONST_STRING)"},
	 { "dafps", _wrap_dafps, METH_VARARGS, "dafps(SpiceInt nd, SpiceInt ni, int * nsum)"},
	 { "dafrfr", _wrap_dafrfr, METH_O, "dafrfr(SpiceInt handle)"},
	 { "dafrs", _wrap_dafrs, METH_O, "dafrs(ConstSpiceDouble * sum)"},
	 { "dasac", _wrap_dasac, METH_VARARGS, "dasac(SpiceInt handle, SpiceInt n)"},
	 { "dasadc", _wrap_dasadc, METH_VARARGS, "dasadc(SpiceInt handle, SpiceInt n, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, ConstSpiceChar * data)"},
	 { "dasadd", _wrap_dasadd, METH_VARARGS, "dasadd(SpiceInt handle, SpiceInt n)"},
	 { "dasadi", _wrap_dasadi, METH_VARARGS, "dasadi(SpiceInt handle, SpiceInt n)"},
	 { "dascls", _wrap_dascls, METH_O, "dascls(SpiceInt handle)"},
	 { "dasdc", _wrap_dasdc, METH_O, "dasdc(SpiceInt handle)"},
	 { "dasec", _wrap_dasec, METH_O, "dasec(SpiceInt handle)"},
	 { "dashfn", _wrap_dashfn, METH_O, "dashfn(SpiceInt handle)"},
	 { "dashfs", _wrap_dashfs, METH_O, "dashfs(SpiceInt handle)"},
	 { "daslla", _wrap_daslla, METH_O, "daslla(SpiceInt handle)"},
	 { "dasllc", _wrap_dasllc, METH_O, "dasllc(SpiceInt handle)"},
	 { "dasonw", _wrap_dasonw, METH_VARARGS, "dasonw(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt ncomr)"},
	 { "dasopr", _wrap_dasopr, METH_O, "dasopr(ConstSpiceChar * CONST_STRING)"},
	 { "dasops", _wrap_dasops, METH_NOARGS, "dasops()"},
	 { "dasopw", _wrap_dasopw, METH_O, "dasopw(ConstSpiceChar * CONST_STRING)"},
	 { "dasrdc", _wrap_dasrdc, METH_VARARGS, "dasrdc(SpiceInt handle, SpiceInt first, SpiceInt last, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, char * data)"},
	 { "dasrdd", _wrap_dasrdd, METH_VARARGS, "dasrdd(SpiceInt handle, SpiceInt first, SpiceInt last)"},
	 { "dasrdi", _wrap_dasrdi, METH_VARARGS, "dasrdi(SpiceInt handle, SpiceInt first, SpiceInt last)"},
	 { "dasrfr", _wrap_dasrfr, METH_O, "dasrfr(SpiceInt handle)"},
	 { "dasudc", _wrap_dasudc, METH_VARARGS, "dasudc(SpiceInt handle, SpiceInt first, SpiceInt last, SpiceInt bpos, SpiceInt epos, SpiceInt datlen, ConstSpiceChar * data)"},
	 { "dasudd", _wrap_dasudd, METH_VARARGS, "dasudd(SpiceInt handle, SpiceInt first, SpiceInt last, ConstSpiceDouble * IN_ARRAY1)"},
	 { "dasudi", _wrap_dasudi, METH_VARARGS, "dasudi(SpiceInt handle, SpiceInt first, SpiceInt last, ConstSpiceInt * IN_ARRAY1)"},
	 { "daswbr", _wrap_daswbr, METH_O, "daswbr(SpiceInt handle)"},
	 { "dazldr", _wrap_dazldr, METH_VARARGS, "dazldr(SpiceDouble x, SpiceDouble y, SpiceDouble z, SpiceBoolean azccw, SpiceBoolean elplsz)"},
	 { "dazldr_vector", _wrap_dazldr_vector, METH_VARARGS, "dazldr_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"},
	 { "dlabbs", _wrap_dlabbs, METH_O, "dlabbs(SpiceInt handle)"},
	 { "dlabfs", _wrap_dlabfs, METH_O, "dlabfs(SpiceInt handle)"},
	 { "dlabns", _wrap_dlabns, METH_O, "dlabns(SpiceInt handle)"},
	 { "dlaens", _wrap_dlaens, METH_O, "dlaens(SpiceInt handle)"},
	 { "dlafns", _wrap_dlafns, METH_VARARGS, "dlafns(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"},
	 { "dlafps", _wrap_dlafps, METH_VARARGS, "dlafps(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"},
	 { "dlaopn", _wrap_dlaopn, METH_VARARGS, "dlaopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceInt ncomch)"},
	 { "dnearp", _wrap_dnearp, METH_VARARGS, "dnearp(ConstSpiceDouble [6] state, SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "dnearp_vector", _wrap_dnearp_vector, METH_VARARGS, "dnearp_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "dp2hx", _wrap_dp2hx, METH_VARARGS, "dp2hx(SpiceDouble number, SpiceChar [256] hxstr)"},
	 { "drdazl", _wrap_drdazl, METH_VARARGS, "drdazl(SpiceDouble range, SpiceDouble az, SpiceDouble el, SpiceBoolean azccw, SpiceBoolean elplsz)"},
	 { "drdazl_vector", _wrap_drdazl_vector, METH_VARARGS, "drdazl_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, SpiceBoolean b1, SpiceBoolean b2)"},
	 { "dskb02", _wrap_dskb02, METH_VARARGS, "dskb02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"},
	 { "dskcls", _wrap_dskcls, METH_VARARGS, "dskcls(SpiceInt handle, SpiceBoolean optmiz)"},
	 { "dskd02", _wrap_dskd02, METH_VARARGS, "dskd02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt item, SpiceInt start)"},
	 { "dskgd", _wrap_dskgd, METH_VARARGS, "dskgd(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"},
	 { "dskgtl", _wrap_dskgtl, METH_O, "dskgtl(SpiceInt keywrd)"},
	 { "dski02", _wrap_dski02, METH_VARARGS, "dski02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt item, SpiceInt start, SpiceInt room)"},
	 { "dskmi2", _wrap_dskmi2, METH_VARARGS, "dskmi2(SpiceInt nv, SpiceInt np, SpiceDouble finscl, SpiceInt corscl, SpiceBoolean makvtl)"},
	 { "dskn02", _wrap_dskn02, METH_VARARGS, "dskn02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt plid)"},
	 { "dskobj", _wrap_dskobj, METH_O, "dskobj(ConstSpiceChar * dskfnm)"},
	 { "dskopn", _wrap_dskopn, METH_VARARGS, "dskopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"},
	 { "dskp02", _wrap_dskp02, METH_VARARGS, "dskp02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt start, SpiceInt room, SpiceInt * n, SpiceInt [NPLATES][3] plates)"},
	 { "dskrb2", _wrap_dskrb2, METH_VARARGS, "dskrb2(SpiceInt nv, SpiceInt np, SpiceInt corsys, ConstSpiceDouble * IN_ARRAY1)"},
	 { "dsksrf", _wrap_dsksrf, METH_VARARGS, "dsksrf(ConstSpiceChar * dskfnm, SpiceInt bodyid)"},
	 { "dskstl", _wrap_dskstl, METH_VARARGS, "dskstl(SpiceInt keywrd, SpiceDouble dpval)"},
	 { "dskv02", _wrap_dskv02, METH_VARARGS, "dskv02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, SpiceInt start, SpiceInt room, SpiceInt * n, SpiceDouble [NPLATES][3] vrtces)"},
	 { "dskw02", _wrap_dskw02, METH_VARARGS, "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)"},
	 { "dskx02", _wrap_dskx02, METH_VARARGS, "dskx02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc, ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] raydir)"},
	 { "dskxsi", _wrap_dskxsi, METH_VARARGS, "dskxsi(SpiceBoolean pri, ConstSpiceChar * target, SpiceInt nsurf, ConstSpiceInt [] srflst, SpiceDouble et, ConstSpiceChar * fixref, ConstSpiceDouble [3] vertex, ConstSpiceDouble [3] raydir)"},
	 { "dskxv", _wrap_dskxv, METH_VARARGS, "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)"},
	 { "dskz02", _wrap_dskz02, METH_VARARGS, "dskz02(SpiceInt handle, ConstSpiceInt [DLASIZE] dladsc)"},
	 { "ednmpt", _wrap_ednmpt, METH_VARARGS, "ednmpt(SpiceDouble a, SpiceDouble b, SpiceDouble c, ConstSpiceDouble [3] normal)"},
	 { "ednmpt_vector", _wrap_ednmpt_vector, METH_VARARGS, "ednmpt_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13, ConstSpiceDouble * in21)"},
	 { "edpnt", _wrap_edpnt, METH_VARARGS, "edpnt(ConstSpiceDouble [3] p, SpiceDouble a, SpiceDouble b, SpiceDouble c)"},
	 { "edpnt_vector", _wrap_edpnt_vector, METH_VARARGS, "edpnt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in13)"},
	 { "ekacec", _wrap_ekacec, METH_VARARGS, "ekacec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, SpiceBoolean isnull)"},
	 { "ekaced", _wrap_ekaced, METH_VARARGS, "ekaced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceDouble [] dvals, SpiceBoolean isnull)"},
	 { "ekacei", _wrap_ekacei, METH_VARARGS, "ekacei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceInt [] ivals, SpiceBoolean isnull)"},
	 { "ekaclc", _wrap_ekaclc, METH_VARARGS, "ekaclc(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, SpiceInt vallen, ConstSpiceChar * cvals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"},
	 { "ekacld", _wrap_ekacld, METH_VARARGS, "ekacld(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, ConstSpiceDouble [] dvals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"},
	 { "ekacli", _wrap_ekacli, METH_VARARGS, "ekacli(SpiceInt handle, SpiceInt segno, ConstSpiceChar * column, ConstSpiceInt [] ivals, ConstSpiceInt [] entszs, ConstSpiceBoolean [] nlflgs, ConstSpiceInt [] rcptrs)"},
	 { "ekappr", _wrap_ekappr, METH_VARARGS, "ekappr(SpiceInt handle, SpiceInt segno)"},
	 { "ekbseg", _wrap_ekbseg, METH_VARARGS, "ekbseg(SpiceInt handle, ConstSpiceChar * CONST_STRING, SpiceInt ncols, SpiceInt declen, ConstSpiceChar * decls)"},
	 { "ekccnt", _wrap_ekccnt, METH_O, "ekccnt(ConstSpiceChar * CONST_STRING)"},
	 { "ekcii", _wrap_ekcii, METH_VARARGS, "ekcii(ConstSpiceChar * table, SpiceInt cindex)"},
	 { "ekcls", _wrap_ekcls, METH_O, "ekcls(SpiceInt handle)"},
	 { "ekdelr", _wrap_ekdelr, METH_VARARGS, "ekdelr(SpiceInt handle, SpiceInt segno, SpiceInt recno)"},
	 { "ekffld", _wrap_ekffld, METH_VARARGS, "ekffld(SpiceInt handle, SpiceInt segno, SpiceInt [] rcptrs)"},
	 { "ekfind", _wrap_ekfind, METH_O, "ekfind(ConstSpiceChar * query)"},
	 { "ekgc", _wrap_ekgc, METH_VARARGS, "ekgc(SpiceInt selidx, SpiceInt row, SpiceInt elment)"},
	 { "ekgd", _wrap_ekgd, METH_VARARGS, "ekgd(SpiceInt selidx, SpiceInt row, SpiceInt elment)"},
	 { "ekgi", _wrap_ekgi, METH_VARARGS, "ekgi(SpiceInt selidx, SpiceInt row, SpiceInt elment)"},
	 { "ekifld", _wrap_ekifld, METH_VARARGS, "ekifld(SpiceInt handle, ConstSpiceChar * tabnam, SpiceInt nrows, SpiceInt ncols, SpiceInt declen, ConstSpiceChar * decls)"},
	 { "ekinsr", _wrap_ekinsr, METH_VARARGS, "ekinsr(SpiceInt handle, SpiceInt segno, SpiceInt recno)"},
	 { "eklef", _wrap_eklef, METH_O, "eklef(ConstSpiceChar * CONST_STRING)"},
	 { "eknelt", _wrap_eknelt, METH_VARARGS, "eknelt(SpiceInt selidx, SpiceInt row) -> SpiceInt"},
	 { "eknseg", _wrap_eknseg, METH_O, "eknseg(SpiceInt handle) -> SpiceInt"},
	 { "ekntab", _wrap_ekntab, METH_NOARGS, "ekntab()"},
	 { "ekopn", _wrap_ekopn, METH_VARARGS, "ekopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"},
	 { "ekopr", _wrap_ekopr, METH_O, "ekopr(ConstSpiceChar * CONST_STRING)"},
	 { "ekops", _wrap_ekops, METH_NOARGS, "ekops()"},
	 { "ekopw", _wrap_ekopw, METH_O, "ekopw(ConstSpiceChar * CONST_STRING)"},
	 { "ekpsel", _wrap_ekpsel, METH_VARARGS, "ekpsel(ConstSpiceChar * query, char [CLAUSES][NAMELEN] tabs, int * n4, char [CLAUSES][NAMELEN] cols, int * n5)"},
	 { "ekrcec", _wrap_ekrcec, METH_VARARGS, "ekrcec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt cvalen, SpiceInt * nvals, char [MAXVALS][COLLEN] cvals)"},
	 { "ekrced", _wrap_ekrced, METH_VARARGS, "ekrced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING)"},
	 { "ekrcei", _wrap_ekrcei, METH_VARARGS, "ekrcei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING)"},
	 { "ekssum", _wrap_ekssum, METH_VARARGS, "ekssum(SpiceInt handle, SpiceInt segno, int * nrows, SpiceChar [SPICE_EK_MXCLSG][NAMELEN] cnames, int * n1)"},
	 { "ektnam", _wrap_ektnam, METH_O, "ektnam(SpiceInt n)"},
	 { "ekucec", _wrap_ekucec, METH_VARARGS, "ekucec(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, SpiceBoolean isnull)"},
	 { "ekuced", _wrap_ekuced, METH_VARARGS, "ekuced(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceDouble [] dvals, SpiceBoolean isnull)"},
	 { "ekucei", _wrap_ekucei, METH_VARARGS, "ekucei(SpiceInt handle, SpiceInt segno, SpiceInt recno, ConstSpiceChar * CONST_STRING, SpiceInt nvals, ConstSpiceInt [] ivals, SpiceBoolean isnull)"},
	 { "ekuef", _wrap_ekuef, METH_O, "ekuef(SpiceInt handle)"},
	 { "evsgp4", _wrap_evsgp4, METH_VARARGS, "evsgp4(SpiceDouble et, ConstSpiceDouble [8] geophs, ConstSpiceDouble [10] elems)"},
	 { "evsgp4_vector", _wrap_evsgp4_vector, METH_VARARGS, "evsgp4_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "esrchc", _wrap_esrchc, METH_VARARGS, "esrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"},
	 { "getelm", _wrap_getelm, METH_VARARGS, "getelm(SpiceInt frstyr, SpiceInt two)"},
	 { "getfat", _wrap_getfat, METH_O, "getfat(ConstSpiceChar * file)"},
	 { "getfvn", _wrap_getfvn, METH_O, "getfvn(ConstSpiceChar * inst)"},
	 { "gfdist", _wrap_gfdist, METH_VARARGS, "gfdist(ConstSpiceChar * target, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"},
	 { "gfevnt", _wrap_gfevnt, METH_VARARGS, "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)"},
	 { "gffove", _wrap_gffove, METH_VARARGS, "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)"},
	 { "gfilum", _wrap_gfilum, METH_VARARGS, "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)"},
	 { "gfocce", _wrap_gfocce, METH_VARARGS, "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)"},
	 { "gfoclt", _wrap_gfoclt, METH_VARARGS, "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)"},
	 { "gfpa", _wrap_gfpa, METH_VARARGS, "gfpa(ConstSpiceChar * target, ConstSpiceChar * illmn, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"},
	 { "gfposc", _wrap_gfposc, METH_VARARGS, "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)"},
	 { "gfrfov", _wrap_gfrfov, METH_VARARGS, "gfrfov(ConstSpiceChar * inst, ConstSpiceDouble [3] raydir, ConstSpiceChar * rframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"},
	 { "gfrr", _wrap_gfrr, METH_VARARGS, "gfrr(ConstSpiceChar * target, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, ConstSpiceChar * relate, SpiceDouble refval, SpiceDouble adjust, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"},
	 { "gfsep", _wrap_gfsep, METH_VARARGS, "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)"},
	 { "gfsntc", _wrap_gfsntc, METH_VARARGS, "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)"},
	 { "gfstol", _wrap_gfstol, METH_O, "gfstol(SpiceDouble value)"},
	 { "gfsubc", _wrap_gfsubc, METH_VARARGS, "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)"},
	 { "gftfov", _wrap_gftfov, METH_VARARGS, "gftfov(ConstSpiceChar * inst, ConstSpiceChar * target, ConstSpiceChar * tshape, ConstSpiceChar * tframe, ConstSpiceChar * abcorr, ConstSpiceChar * obsrvr, SpiceDouble step, SpiceDouble et0, SpiceDouble et1)"},
	 { "hrmesp", _wrap_hrmesp, METH_VARARGS, "hrmesp(SpiceDouble first, SpiceDouble step, ConstSpiceDouble * yvals, SpiceDouble x)"},
	 { "hrmesp_vector", _wrap_hrmesp_vector, METH_VARARGS, "hrmesp_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13)"},
	 { "hrmint", _wrap_hrmint, METH_VARARGS, "hrmint(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x)"},
	 { "hrmint_vector", _wrap_hrmint_vector, METH_VARARGS, "hrmint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in31, ConstSpiceDouble * in11)"},
	 { "hx2dp", _wrap_hx2dp, METH_O, "hx2dp(ConstSpiceChar * string)"},
	 { "invstm", _wrap_invstm, METH_O, "invstm(ConstSpiceDouble [6][6] mat)"},
	 { "invstm_vector", _wrap_invstm_vector, METH_O, "invstm_vector(ConstSpiceDouble * in31)"},
	 { "isrchc", _wrap_isrchc, METH_VARARGS, "isrchc(ConstSpiceChar * CONST_STRING, SpiceInt ndim) -> SpiceInt"},
	 { "isrchd", _wrap_isrchd, METH_VARARGS, "isrchd(SpiceDouble value, SpiceInt ndim) -> SpiceInt"},
	 { "isrchi", _wrap_isrchi, METH_VARARGS, "isrchi(SpiceInt value, SpiceInt ndim) -> SpiceInt"},
	 { "isordv", _wrap_isordv, METH_VARARGS, "isordv(ConstSpiceInt [] array, SpiceInt n) -> SpiceBoolean"},
	 { "iswhsp", _wrap_iswhsp, METH_O, "iswhsp(ConstSpiceChar * CONST_STRING) -> SpiceBoolean"},
	 { "kclear", _wrap_kclear, METH_NOARGS, "kclear()"},
	 { "kdata", _wrap_kdata, METH_VARARGS, "kdata(SpiceInt which, ConstSpiceChar * kind, SpiceInt fileln, SpiceChar * file, SpiceInt filtln, SpiceChar * filtyp, SpiceInt srclen, SpiceChar * srcfil)"},
	 { "kinfo", _wrap_kinfo, METH_O, "kinfo(ConstSpiceChar * file)"},
	 { "ktotal", _wrap_ktotal, METH_O, "ktotal(ConstSpiceChar * CONST_STRING)"},
	 { "kxtrct", _wrap_kxtrct, METH_VARARGS, "kxtrct(ConstSpiceChar * keywd, SpiceInt nterms, SpiceInt worlen)"},
	 { "lgresp", _wrap_lgresp, METH_VARARGS, "lgresp(SpiceDouble first, SpiceDouble step, ConstSpiceDouble * yvals, SpiceDouble x) -> SpiceDouble"},
	 { "lgresp_vector", _wrap_lgresp_vector, METH_VARARGS, "lgresp_vector(ConstSpiceDouble * in11, ConstSpiceDouble * in12, ConstSpiceDouble * in21, ConstSpiceDouble * in13)"},
	 { "lgrind", _wrap_lgrind, METH_VARARGS, "lgrind(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x)"},
	 { "lgrind_vector", _wrap_lgrind_vector, METH_VARARGS, "lgrind_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "lgrint", _wrap_lgrint, METH_VARARGS, "lgrint(ConstSpiceDouble * xvals, ConstSpiceDouble * yvals, SpiceDouble x) -> SpiceDouble"},
	 { "lgrint_vector", _wrap_lgrint_vector, METH_VARARGS, "lgrint_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in11)"},
	 { "lmpool", _wrap_lmpool, METH_O, "lmpool(ConstSpiceChar * cvals)"},
	 { "lparse", _wrap_lparse, METH_VARARGS, "lparse(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"},
	 { "lparsm", _wrap_lparsm, METH_VARARGS, "lparsm(ConstSpiceChar * arg1, ConstSpiceChar * arg2)"},
	 { "lstlec", _wrap_lstlec, METH_VARARGS, "lstlec(ConstSpiceChar * CONST_STRING, SpiceInt n) -> SpiceInt"},
	 { "lstled", _wrap_lstled, METH_VARARGS, "lstled(SpiceDouble x, SpiceInt n) -> SpiceInt"},
	 { "lstlei", _wrap_lstlei, METH_VARARGS, "lstlei(SpiceInt x, SpiceInt n) -> SpiceInt"},
	 { "lstltc", _wrap_lstltc, METH_VARARGS, "lstltc(ConstSpiceChar * CONST_STRING, SpiceInt n) -> SpiceInt"},
	 { "lstltd", _wrap_lstltd, METH_VARARGS, "lstltd(SpiceDouble x, SpiceInt n) -> SpiceInt"},
	 { "lstlti", _wrap_lstlti, METH_VARARGS, "lstlti(SpiceInt x, SpiceInt n) -> SpiceInt"},
	 { "lx4dec", _wrap_lx4dec, METH_VARARGS, "lx4dec(ConstSpiceChar * CONST_STRING, SpiceInt first)"},
	 { "lx4num", _wrap_lx4num, METH_VARARGS, "lx4num(ConstSpiceChar * CONST_STRING, SpiceInt first)"},
	 { "lx4sgn", _wrap_lx4sgn, METH_VARARGS, "lx4sgn(ConstSpiceChar * CONST_STRING, SpiceInt first)"},
	 { "lx4uns", _wrap_lx4uns, METH_VARARGS, "lx4uns(ConstSpiceChar * CONST_STRING, SpiceInt first)"},
	 { "lxqstr", _wrap_lxqstr, METH_VARARGS, "lxqstr(ConstSpiceChar * CONST_STRING, SpiceChar IN_STRING, SpiceInt first)"},
	 { "matchi", _wrap_matchi, METH_VARARGS, "matchi(ConstSpiceChar * arg1, SpiceChar * arg2, SpiceChar arg3, SpiceChar arg4)"},
	 { "matchw", _wrap_matchw, METH_VARARGS, "matchw(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceChar arg3, SpiceChar arg4)"},
	 { "ncpos", _wrap_ncpos, METH_VARARGS, "ncpos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "ncposr", _wrap_ncposr, METH_VARARGS, "ncposr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "nextwd", _wrap_nextwd, METH_O, "nextwd(ConstSpiceChar * string)"},
	 { "nthwd", _wrap_nthwd, METH_VARARGS, "nthwd(ConstSpiceChar * CONST_STRING, SpiceInt nth)"},
	 { "orderc", _wrap_orderc, METH_VARARGS, "orderc(SpiceInt ndim, SpiceInt * n, SpiceInt ** iorder)"},
	 { "orderd", _wrap_orderd, METH_VARARGS, "orderd(ConstSpiceDouble * array, SpiceInt * n, SpiceInt ** iorder)"},
	 { "orderi", _wrap_orderi, METH_VARARGS, "orderi(ConstSpiceInt * array, SpiceInt * n, SpiceInt ** iorder)"},
	 { "pckcls", _wrap_pckcls, METH_O, "pckcls(SpiceInt handle)"},
	 { "pcklof", _wrap_pcklof, METH_O, "pcklof(ConstSpiceChar * CONST_STRING)"},
	 { "pckopn", _wrap_pckopn, METH_VARARGS, "pckopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"},
	 { "pckuof", _wrap_pckuof, METH_O, "pckuof(SpiceInt handle)"},
	 { "pckw02", _wrap_pckw02, METH_VARARGS, "pckw02(SpiceInt handle, SpiceInt clssid, ConstSpiceChar * arg3, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg6, SpiceDouble intlen, SpiceInt n, SpiceInt polydg, SpiceDouble * IN_ARRAY1, SpiceDouble btime)"},
	 { "pltnrm", _wrap_pltnrm, METH_VARARGS, "pltnrm(ConstSpiceDouble [3] v1, ConstSpiceDouble [3] v2, ConstSpiceDouble [3] v3)"},
	 { "pltnrm_vector", _wrap_pltnrm_vector, METH_VARARGS, "pltnrm_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22, ConstSpiceDouble * in23)"},
	 { "polyds", _wrap_polyds, METH_VARARGS, "polyds(SpiceInt deg_plus_1, SpiceInt nderiv, SpiceDouble t)"},
	 { "polyds_vector", _wrap_polyds_vector, METH_VARARGS, "polyds_vector(ConstSpiceDouble * in21, SpiceInt nderiv, ConstSpiceDouble * in12)"},
	 { "pos", _wrap_pos, METH_VARARGS, "pos(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "posr", _wrap_posr, METH_VARARGS, "posr(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt start) -> SpiceInt"},
	 { "prompt", _wrap_prompt, METH_O, "prompt(ConstSpiceChar * CONST_STRING) -> SpiceChar *"},
	 { "prsdp", _wrap_prsdp, METH_O, "prsdp(ConstSpiceChar * CONST_STRING)"},
	 { "prsint", _wrap_prsint, METH_O, "prsint(ConstSpiceChar * CONST_STRING)"},
	 { "qderiv", _wrap_qderiv, METH_VARARGS, "qderiv(SpiceInt ndim, SpiceInt ndim1, SpiceDouble delta, SpiceInt * ndim2, SpiceDouble ** dfdt)"},
	 { "recazl", _wrap_recazl, METH_VARARGS, "recazl(ConstSpiceDouble [3] rectan, SpiceBoolean azccw, SpiceBoolean elplsz)"},
	 { "recazl_vector", _wrap_recazl_vector, METH_VARARGS, "recazl_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceDouble * in12)"},
	 { "reordc", _wrap_reordc, METH_VARARGS, "reordc(ConstSpiceInt * iorder, SpiceInt ndim)"},
	 { "reordd", _wrap_reordd, METH_VARARGS, "reordd(ConstSpiceInt * iorder, SpiceInt ndim, SpiceDouble * array)"},
	 { "reordi", _wrap_reordi, METH_VARARGS, "reordi(ConstSpiceInt * iorder, SpiceInt ndim, SpiceInt * array)"},
	 { "reordl", _wrap_reordl, METH_VARARGS, "reordl(ConstSpiceInt * iorder, SpiceInt ndim, SpiceBoolean * array)"},
	 { "repml", _wrap_repml, METH_VARARGS, "repml(ConstSpiceDouble * arg1, ConstSpiceDouble * arg2, SpiceBoolean value, SpiceChar IN_STRING)"},
	 { "return_", _wrap_return_, METH_NOARGS, "return_() -> SpiceBoolean"},
	 { "shellc", _wrap_shellc, METH_O, "shellc(SpiceInt ndim)"},
	 { "shelld", _wrap_shelld, METH_VARARGS, "shelld(SpiceInt ndim, SpiceDouble * array)"},
	 { "shelli", _wrap_shelli, METH_VARARGS, "shelli(SpiceInt ndim, SpiceInt * array)"},
	 { "spk14a", _wrap_spk14a, METH_VARARGS, "spk14a(SpiceInt handle, SpiceInt ncsets, ConstSpiceDouble * arg3, ConstSpiceDouble * arg4)"},
	 { "spk14b", _wrap_spk14b, METH_VARARGS, "spk14b(SpiceInt handle, ConstSpiceChar * arg2, SpiceInt body, SpiceInt center, ConstSpiceChar * arg5, SpiceDouble first, SpiceDouble last, SpiceInt chbdeg)"},
	 { "spk14e", _wrap_spk14e, METH_O, "spk14e(SpiceInt handle)"},
	 { "spkcls", _wrap_spkcls, METH_O, "spkcls(SpiceInt handle)"},
	 { "spkcpo", _wrap_spkcpo, METH_VARARGS, "spkcpo(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceDouble [3] obspos, ConstSpiceChar * arg7, ConstSpiceChar * arg8)"},
	 { "spkcpo_vector", _wrap_spkcpo_vector, METH_VARARGS, "spkcpo_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in21, ConstSpiceChar * str5, ConstSpiceChar * str6)"},
	 { "spkcpt", _wrap_spkcpt, METH_VARARGS, "spkcpt(ConstSpiceDouble [3] trgpos, ConstSpiceChar * arg2, ConstSpiceChar * arg3, SpiceDouble et, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8)"},
	 { "spkcpt_vector", _wrap_spkcpt_vector, METH_VARARGS, "spkcpt_vector(ConstSpiceDouble * in21, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6)"},
	 { "spkcvo", _wrap_spkcvo, METH_VARARGS, "spkcvo(ConstSpiceChar * arg1, SpiceDouble et, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceDouble [6] obssta, SpiceDouble obsepc, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"},
	 { "spkcvo_vector", _wrap_spkcvo_vector, METH_VARARGS, "spkcvo_vector(ConstSpiceChar * str1, ConstSpiceDouble * in11, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceDouble * in21, ConstSpiceDouble * in12, ConstSpiceChar * str5, ConstSpiceChar * str6)"},
	 { "spkcvt", _wrap_spkcvt, METH_VARARGS, "spkcvt(ConstSpiceDouble [6] trgsta, SpiceDouble trgepc, ConstSpiceChar * arg3, ConstSpiceChar * arg4, SpiceDouble et, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceChar * arg9)"},
	 { "spkcvt_vector", _wrap_spkcvt_vector, METH_VARARGS, "spkcvt_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in12, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6)"},
	 { "spklef", _wrap_spklef, METH_O, "spklef(ConstSpiceChar * CONST_STRING)"},
	 { "spkopa", _wrap_spkopa, METH_O, "spkopa(ConstSpiceChar * CONST_STRING)"},
	 { "spkopn", _wrap_spkopn, METH_VARARGS, "spkopn(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceInt ncomch)"},
	 { "spkpds", _wrap_spkpds, METH_VARARGS, "spkpds(SpiceInt body, SpiceInt center, ConstSpiceChar * CONST_STRING, SpiceInt type, SpiceDouble first, SpiceDouble last)"},
	 { "spkpvn", _wrap_spkpvn, METH_VARARGS, "spkpvn(SpiceInt handle, ConstSpiceDouble [5] descr, SpiceDouble et)"},
	 { "spksfs", _wrap_spksfs, METH_VARARGS, "spksfs(SpiceInt body, SpiceDouble et, SpiceInt idlen, SpiceChar * ident)"},
	 { "spksub", _wrap_spksub, METH_VARARGS, "spksub(SpiceInt handle, SpiceDouble [5] descr, ConstSpiceChar * CONST_STRING, SpiceDouble begin, SpiceDouble end, SpiceInt newh)"},
	 { "spkuds", _wrap_spkuds, METH_O, "spkuds(ConstSpiceDouble [5] descr)"},
	 { "spkuef", _wrap_spkuef, METH_O, "spkuef(SpiceInt handle)"},
	 { "spkw02", _wrap_spkw02, METH_VARARGS, "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)"},
	 { "spkw03", _wrap_spkw03, METH_VARARGS, "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)"},
	 { "spkw05", _wrap_spkw05, METH_VARARGS, "spkw05(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble gm, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"},
	 { "spkw08", _wrap_spkw08, METH_VARARGS, "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)"},
	 { "spkw09", _wrap_spkw09, METH_VARARGS, "spkw09(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"},
	 { "spkw10", _wrap_spkw10, METH_VARARGS, "spkw10(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, ConstSpiceDouble [8] consts, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"},
	 { "spkw12", _wrap_spkw12, METH_VARARGS, "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)"},
	 { "spkw13", _wrap_spkw13, METH_VARARGS, "spkw13(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceInt degree, SpiceInt n, ConstSpiceDouble * arg10, ConstSpiceDouble * arg11)"},
	 { "spkw15", _wrap_spkw15, METH_VARARGS, "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)"},
	 { "spkw17", _wrap_spkw17, METH_VARARGS, "spkw17(SpiceInt handle, SpiceInt body, SpiceInt center, ConstSpiceChar * arg4, SpiceDouble first, SpiceDouble last, ConstSpiceChar * arg7, SpiceDouble epoch, ConstSpiceDouble [9] eqel, SpiceDouble rapol, SpiceDouble decpol)"},
	 { "spkw18", _wrap_spkw18, METH_VARARGS, "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)"},
	 { "spkw20", _wrap_spkw20, METH_VARARGS, "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)"},
	 { "sumad", _wrap_sumad, METH_O, "sumad(ConstSpiceDouble * array) -> SpiceDouble"},
	 { "sumai", _wrap_sumai, METH_O, "sumai(ConstSpiceInt * array) -> SpiceInt"},
	 { "swpool", _wrap_swpool, METH_VARARGS, "swpool(ConstSpiceChar * CONST_STRING, SpiceInt nnames)"},
	 { "szpool", _wrap_szpool, METH_O, "szpool(ConstSpiceChar * CONST_STRING)"},
	 { "tangpt", _wrap_tangpt, METH_VARARGS, "tangpt(ConstSpiceChar * arg1, ConstSpiceChar * arg2, SpiceDouble et, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceDouble [3] dvec)"},
	 { "tangpt_vector", _wrap_tangpt_vector, METH_VARARGS, "tangpt_vector(ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceDouble * in11, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceDouble * in21)"},
	 { "tkfram", _wrap_tkfram, METH_O, "tkfram(SpiceInt frcode)"},
	 { "tparch", _wrap_tparch, METH_O, "tparch(ConstSpiceChar * CONST_STRING)"},
	 { "trgsep", _wrap_trgsep, METH_VARARGS, "trgsep(SpiceDouble et, ConstSpiceChar * arg2, ConstSpiceChar * arg3, ConstSpiceChar * arg4, ConstSpiceChar * arg5, ConstSpiceChar * arg6, ConstSpiceChar * arg7, ConstSpiceChar * arg8, ConstSpiceChar * arg9) -> SpiceDouble"},
	 { "trgsep_vector", _wrap_trgsep_vector, METH_VARARGS, "trgsep_vector(ConstSpiceDouble * in11, ConstSpiceChar * str1, ConstSpiceChar * str2, ConstSpiceChar * str3, ConstSpiceChar * str4, ConstSpiceChar * str5, ConstSpiceChar * str6, ConstSpiceChar * str7, ConstSpiceChar * str8)"},
	 { "twovxf", _wrap_twovxf, METH_VARARGS, "twovxf(ConstSpiceDouble [6] axdef, SpiceInt indexa, ConstSpiceDouble [6] plndef, SpiceInt indexp)"},
	 { "twovxf_vector", _wrap_twovxf_vector, METH_VARARGS, "twovxf_vector(ConstSpiceDouble * in21, SpiceInt k1, ConstSpiceDouble * in22, SpiceInt k2)"},
	 { "vprojg", _wrap_vprojg, METH_VARARGS, "vprojg(ConstSpiceDouble * a, ConstSpiceDouble * b)"},
	 { "my_vprojg_nomalloc", _wrap_my_vprojg_nomalloc, METH_VARARGS, "my_vprojg_nomalloc(ConstSpiceDouble * a, ConstSpiceDouble * b, SpiceInt * ndim2)"},
	 { "vprojg_vector", _wrap_vprojg_vector, METH_VARARGS, "vprojg_vector(ConstSpiceDouble * in21, ConstSpiceDouble * in22)"},
	 { "wncomd", _wrap_wncomd, METH_VARARGS, "wncomd(SpiceDouble left, SpiceDouble right, int n)"},
	 { "wncond", _wrap_wncond, METH_VARARGS, "wncond(SpiceDouble left, SpiceDouble right, int n)"},
	 { "wndifd", _wrap_wndifd, METH_VARARGS, "wndifd(int na, int nb)"},
	 { "wnelmd", _wrap_wnelmd, METH_VARARGS, "wnelmd(SpiceDouble point, int n) -> SpiceBoolean"},
	 { "wnexpd", _wrap_wnexpd, METH_VARARGS, "wnexpd(SpiceDouble left, SpiceDouble right, int n)"},
	 { "wnextd", _wrap_wnextd, METH_VARARGS, "wnextd(SpiceChar side, int n)"},
	 { "wnfild", _wrap_wnfild, METH_VARARGS, "wnfild(SpiceDouble smlgap, int n)"},
	 { "wnfltd", _wrap_wnfltd, METH_VARARGS, "wnfltd(SpiceDouble smlint, int n)"},
	 { "wnincd", _wrap_wnincd, METH_VARARGS, "wnincd(SpiceDouble left, SpiceDouble right, int n) -> SpiceBoolean"},
	 { "wninsd", _wrap_wninsd, METH_VARARGS, "wninsd(SpiceDouble left, SpiceDouble right, int n)"},
	 { "wnintd", _wrap_wnintd, METH_VARARGS, "wnintd(int na, int nb)"},
	 { "wnreld", _wrap_wnreld, METH_VARARGS, "wnreld(int na, ConstSpiceChar * op, int nb) -> SpiceBoolean"},
	 { "wnsumd", _wrap_wnsumd, METH_O, "wnsumd(int n)"},
	 { "wnunid", _wrap_wnunid, METH_VARARGS, "wnunid(int na, int nb)"},
	 { NULL, NULL, 0, NULL }
};

static PyMethodDef SwigMethods_proxydocs[] = {
	 { NULL, NULL, 0, NULL }
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static swig_type_info _swigt__p_ConstSpiceBoolean = {"_p_ConstSpiceBoolean", "ConstSpiceBoolean *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstSpiceChar = {"_p_ConstSpiceChar", "ConstSpiceChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstSpiceDouble = {"_p_ConstSpiceDouble", "ConstSpiceDouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ConstSpiceInt = {"_p_ConstSpiceInt", "ConstSpiceInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpiceBoolean = {"_p_SpiceBoolean", "SpiceBoolean *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpiceChar = {"_p_SpiceChar", "SpiceChar *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpiceDouble = {"_p_SpiceDouble", "SpiceDouble *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SpiceInt = {"_p_SpiceInt", "SpiceInt *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__ConstSpiceDouble = {"_p_a_2__ConstSpiceDouble", "ConstSpiceDouble (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_2__SpiceDouble = {"_p_a_2__SpiceDouble", "SpiceDouble (*)[2]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__ConstSpiceDouble = {"_p_a_3__ConstSpiceDouble", "ConstSpiceDouble (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__ConstSpiceInt = {"_p_a_3__ConstSpiceInt", "ConstSpiceInt (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__SpiceDouble = {"_p_a_3__SpiceDouble", "SpiceDouble (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_3__SpiceInt = {"_p_a_3__SpiceInt", "SpiceInt (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_4__ConstSpiceDouble = {"_p_a_4__ConstSpiceDouble", "ConstSpiceDouble (*)[4]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_6__ConstSpiceDouble = {"_p_a_6__ConstSpiceDouble", "ConstSpiceDouble (*)[6]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_6__SpiceDouble = {"_p_a_6__SpiceDouble", "SpiceDouble (*)[6]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_COLLEN__char = {"_p_a_COLLEN__char", "char (*)[COLLEN]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_COMMENTLEN__char = {"_p_a_COMMENTLEN__char", "char (*)[COMMENTLEN]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_KERVALLEN__char = {"_p_a_KERVALLEN__char", "char (*)[KERVALLEN]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NAMELEN__SpiceChar = {"_p_a_NAMELEN__SpiceChar", "SpiceChar (*)[NAMELEN]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_a_NAMELEN__char = {"_p_a_NAMELEN__char", "char (*)[NAMELEN]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SpiceBoolean = {"_p_p_SpiceBoolean", "SpiceBoolean **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SpiceDouble = {"_p_p_SpiceDouble", "SpiceDouble **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_SpiceInt = {"_p_p_SpiceInt", "SpiceInt **", 0, 0, (void*)0, 0};

static swig_type_info *swig_type_initial[] = {
  &_swigt__p_ConstSpiceBoolean,
  &_swigt__p_ConstSpiceChar,
  &_swigt__p_ConstSpiceDouble,
  &_swigt__p_ConstSpiceInt,
  &_swigt__p_SpiceBoolean,
  &_swigt__p_SpiceChar,
  &_swigt__p_SpiceDouble,
  &_swigt__p_SpiceInt,
  &_swigt__p_a_2__ConstSpiceDouble,
  &_swigt__p_a_2__SpiceDouble,
  &_swigt__p_a_3__ConstSpiceDouble,
  &_swigt__p_a_3__ConstSpiceInt,
  &_swigt__p_a_3__SpiceDouble,
  &_swigt__p_a_3__SpiceInt,
  &_swigt__p_a_4__ConstSpiceDouble,
  &_swigt__p_a_6__ConstSpiceDouble,
  &_swigt__p_a_6__SpiceDouble,
  &_swigt__p_a_COLLEN__char,
  &_swigt__p_a_COMMENTLEN__char,
  &_swigt__p_a_KERVALLEN__char,
  &_swigt__p_a_NAMELEN__SpiceChar,
  &_swigt__p_a_NAMELEN__char,
  &_swigt__p_char,
  &_swigt__p_int,
  &_swigt__p_p_SpiceBoolean,
  &_swigt__p_p_SpiceDouble,
  &_swigt__p_p_SpiceInt,
};

static swig_cast_info _swigc__p_ConstSpiceBoolean[] = {  {&_swigt__p_ConstSpiceBoolean, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstSpiceChar[] = {  {&_swigt__p_ConstSpiceChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstSpiceDouble[] = {  {&_swigt__p_ConstSpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ConstSpiceInt[] = {  {&_swigt__p_ConstSpiceInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpiceBoolean[] = {  {&_swigt__p_SpiceBoolean, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpiceChar[] = {  {&_swigt__p_SpiceChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpiceDouble[] = {  {&_swigt__p_SpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SpiceInt[] = {  {&_swigt__p_SpiceInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__ConstSpiceDouble[] = {  {&_swigt__p_a_2__ConstSpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_2__SpiceDouble[] = {  {&_swigt__p_a_2__SpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__ConstSpiceDouble[] = {  {&_swigt__p_a_3__ConstSpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__ConstSpiceInt[] = {  {&_swigt__p_a_3__ConstSpiceInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__SpiceDouble[] = {  {&_swigt__p_a_3__SpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_3__SpiceInt[] = {  {&_swigt__p_a_3__SpiceInt, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_4__ConstSpiceDouble[] = {  {&_swigt__p_a_4__ConstSpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_6__ConstSpiceDouble[] = {  {&_swigt__p_a_6__ConstSpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_6__SpiceDouble[] = {  {&_swigt__p_a_6__SpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_COLLEN__char[] = {  {&_swigt__p_a_COLLEN__char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_COMMENTLEN__char[] = {  {&_swigt__p_a_COMMENTLEN__char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_KERVALLEN__char[] = {  {&_swigt__p_a_KERVALLEN__char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NAMELEN__SpiceChar[] = {  {&_swigt__p_a_NAMELEN__SpiceChar, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_a_NAMELEN__char[] = {  {&_swigt__p_a_NAMELEN__char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SpiceBoolean[] = {  {&_swigt__p_p_SpiceBoolean, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SpiceDouble[] = {  {&_swigt__p_p_SpiceDouble, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_SpiceInt[] = {  {&_swigt__p_p_SpiceInt, 0, 0, 0},{0, 0, 0, 0}};

static swig_cast_info *swig_cast_initial[] = {
  _swigc__p_ConstSpiceBoolean,
  _swigc__p_ConstSpiceChar,
  _swigc__p_ConstSpiceDouble,
  _swigc__p_ConstSpiceInt,
  _swigc__p_SpiceBoolean,
  _swigc__p_SpiceChar,
  _swigc__p_SpiceDouble,
  _swigc__p_SpiceInt,
  _swigc__p_a_2__ConstSpiceDouble,
  _swigc__p_a_2__SpiceDouble,
  _swigc__p_a_3__ConstSpiceDouble,
  _swigc__p_a_3__ConstSpiceInt,
  _swigc__p_a_3__SpiceDouble,
  _swigc__p_a_3__SpiceInt,
  _swigc__p_a_4__ConstSpiceDouble,
  _swigc__p_a_6__ConstSpiceDouble,
  _swigc__p_a_6__SpiceDouble,
  _swigc__p_a_COLLEN__char,
  _swigc__p_a_COMMENTLEN__char,
  _swigc__p_a_KERVALLEN__char,
  _swigc__p_a_NAMELEN__SpiceChar,
  _swigc__p_a_NAMELEN__char,
  _swigc__p_char,
  _swigc__p_int,
  _swigc__p_p_SpiceBoolean,
  _swigc__p_p_SpiceDouble,
  _swigc__p_p_SpiceInt,
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

static swig_const_info swig_const_table[] = {
{0, 0, 0, 0.0, 0, 0}};

#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
 * Type initialization:
 * This problem is tough by the requirement that no dynamic
 * memory is used. Also, since swig_type_info structures store pointers to
 * swig_cast_info structures and swig_cast_info structures store pointers back
 * to swig_type_info structures, we need some lookup code at initialization.
 * The idea is that swig generates all the structures that are needed.
 * The runtime then collects these partially filled structures.
 * The SWIG_InitializeModule function takes these initial arrays out of
 * swig_module, and does all the lookup, filling in the swig_module.types
 * array with the correct data and linking the correct swig_cast_info
 * structures together.
 *
 * The generated swig_type_info structures are assigned statically to an initial
 * array. We just loop through that array, and handle each type individually.
 * First we lookup if this type has been already loaded, and if so, use the
 * loaded structure instead of the generated one. Then we have to fill in the
 * cast linked list. The cast data is initially stored in something like a
 * two-dimensional array. Each row corresponds to a type (there are the same
 * number of rows as there are in the swig_type_initial array). Each entry in
 * a column is one of the swig_cast_info structures for that type.
 * The cast_initial array is actually an array of arrays, because each row has
 * a variable number of columns. So to actually build the cast linked list,
 * we find the array of casts associated with the type, and loop through it
 * adding the casts to the list. The one last trick we need to do is making
 * sure the type pointer in the swig_cast_info struct is correct.
 *
 * First off, we lookup the cast->type name to see if it is already loaded.
 * There are three cases to handle:
 *  1) If the cast->type has already been loaded AND the type we are adding
 *     casting info to has not been loaded (it is in this module), THEN we
 *     replace the cast->type pointer with the type pointer that has already
 *     been loaded.
 *  2) If BOTH types (the one we are adding casting info to, and the
 *     cast->type) are loaded, THEN the cast info has already been loaded by
 *     the previous module so we just ignore it.
 *  3) Finally, if cast->type has not already been loaded, then we add that
 *     swig_cast_info to the linked list (because the cast->type) pointer will
 *     be correct.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus
extern "C" {
#if 0
} /* c-mode */
#endif
#endif

#if 0
#define SWIGRUNTIME_DEBUG
#endif


SWIGRUNTIME void
SWIG_InitializeModule(void *clientdata) {
  size_t i;
  swig_module_info *module_head, *iter;
  int init;
  
  /* check to see if the circular list has been setup, if not, set it up */
  if (swig_module.next==0) {
    /* Initialize the swig_module */
    swig_module.type_initial = swig_type_initial;
    swig_module.cast_initial = swig_cast_initial;
    swig_module.next = &swig_module;
    init = 1;
  } else {
    init = 0;
  }
  
  /* Try and load any already created modules */
  module_head = SWIG_GetModule(clientdata);
  if (!module_head) {
    /* This is the first module loaded for this interpreter */
    /* so set the swig module into the interpreter */
    SWIG_SetModule(clientdata, &swig_module);
  } else {
    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
    iter=module_head;
    do {
      if (iter==&swig_module) {
        /* Our module is already in the list, so there's nothing more to do. */
        return;
      }
      iter=iter->next;
    } while (iter!= module_head);
    
    /* otherwise we must add our module into the list */
    swig_module.next = module_head->next;
    module_head->next = &swig_module;
  }
  
  /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
  if (init == 0) return;
  
  /* Now work on filling in swig_module.types */
#ifdef SWIGRUNTIME_DEBUG
  printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
#endif
  for (i = 0; i < swig_module.size; ++i) {
    swig_type_info *type = 0;
    swig_type_info *ret;
    swig_cast_info *cast;
    
#ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
#endif
    
    /* if there is another module already loaded */
    if (swig_module.next != &swig_module) {
      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
    }
    if (type) {
      /* Overwrite clientdata field */
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: found type %s\n", type->name);
#endif
      if (swig_module.type_initial[i]->clientdata) {
        type->clientdata = swig_module.type_initial[i]->clientdata;
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
#endif
      }
    } else {
      type = swig_module.type_initial[i];
    }
    
    /* Insert casting types */
    cast = swig_module.cast_initial[i];
    while (cast->type) {
      /* Don't need to add information already in the list */
      ret = 0;
#ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
#endif
      if (swig_module.next != &swig_module) {
        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
#ifdef SWIGRUNTIME_DEBUG
        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
#endif
      }
      if (ret) {
        if (type == swig_module.type_initial[i]) {
#ifdef SWIGRUNTIME_DEBUG
          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
#endif
          cast->type = ret;
          ret = 0;
        } else {
          /* Check for casting already in the list */
          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
#ifdef SWIGRUNTIME_DEBUG
          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
#endif
          if (!ocast) ret = 0;
        }
      }
      
      if (!ret) {
#ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
#endif
        if (type->cast) {
          type->cast->prev = cast;
          cast->next = type->cast;
        }
        type->cast = cast;
      }
      cast++;
    }
    /* Set entry in modules->types array equal to the type */
    swig_module.types[i] = type;
  }
  swig_module.types[i] = 0;
  
#ifdef SWIGRUNTIME_DEBUG
  printf("**** SWIG_InitializeModule: Cast List ******\n");
  for (i = 0; i < swig_module.size; ++i) {
    int j = 0;
    swig_cast_info *cast = swig_module.cast_initial[i];
    printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
    while (cast->type) {
      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
      cast++;
      ++j;
    }
    printf("---- Total casts: %d\n",j);
  }
  printf("**** SWIG_InitializeModule: Cast List ******\n");
#endif
}

/* This function will propagate the clientdata field of type to
* any new swig_type_info structures that have been added into the list
* of equivalent types.  It is like calling
* SWIG_TypeClientData(type, clientdata) a second time.
*/
SWIGRUNTIME void
SWIG_PropagateClientData(void) {
  size_t i;
  swig_cast_info *equiv;
  static int init_run = 0;
  
  if (init_run) return;
  init_run = 1;
  
  for (i = 0; i < swig_module.size; i++) {
    if (swig_module.types[i]->clientdata) {
      equiv = swig_module.types[i]->cast;
      while (equiv) {
        if (!equiv->converter) {
          if (equiv->type && !equiv->type->clientdata)
          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
        }
        equiv = equiv->next;
      }
    }
  }
}

#ifdef __cplusplus
#if 0
{
  /* c-mode */
#endif
}
#endif



#ifdef __cplusplus
extern "C" {
#endif
  
  /* Python-specific SWIG API */
#define SWIG_newvarlink()                             SWIG_Python_newvarlink()
#define SWIG_addvarlink(p, name, get_attr, set_attr)  SWIG_Python_addvarlink(p, name, get_attr, set_attr)
#define SWIG_InstallConstants(d, constants)           SWIG_Python_InstallConstants(d, constants)
  
  /* -----------------------------------------------------------------------------
   * global variable support code.
   * ----------------------------------------------------------------------------- */
  
  typedef struct swig_globalvar {
    char       *name;                  /* Name of global variable */
    PyObject *(*get_attr)(void);       /* Return the current value */
    int       (*set_attr)(PyObject *); /* Set the value */
    struct swig_globalvar *next;
  } swig_globalvar;
  
  typedef struct swig_varlinkobject {
    PyObject_HEAD
    swig_globalvar *vars;
  } swig_varlinkobject;
  
  SWIGINTERN PyObject *
  swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
#if PY_VERSION_HEX >= 0x03000000
    return PyUnicode_InternFromString("<Swig global variables>");
#else
    return PyString_FromString("<Swig global variables>");
#endif
  }
  
  SWIGINTERN PyObject *
  swig_varlink_str(swig_varlinkobject *v) {
#if PY_VERSION_HEX >= 0x03000000
    PyObject *str = PyUnicode_InternFromString("(");
    PyObject *tail;
    PyObject *joined;
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      tail = PyUnicode_FromString(var->name);
      joined = PyUnicode_Concat(str, tail);
      Py_DecRef(str);
      Py_DecRef(tail);
      str = joined;
      if (var->next) {
        tail = PyUnicode_InternFromString(", ");
        joined = PyUnicode_Concat(str, tail);
        Py_DecRef(str);
        Py_DecRef(tail);
        str = joined;
      }
    }
    tail = PyUnicode_InternFromString(")");
    joined = PyUnicode_Concat(str, tail);
    Py_DecRef(str);
    Py_DecRef(tail);
    str = joined;
#else
    PyObject *str = PyString_FromString("(");
    swig_globalvar *var;
    for (var = v->vars; var; var=var->next) {
      PyString_ConcatAndDel(&str,PyString_FromString(var->name));
      if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
    }
    PyString_ConcatAndDel(&str,PyString_FromString(")"));
#endif
    return str;
  }
  
  SWIGINTERN void
  swig_varlink_dealloc(swig_varlinkobject *v) {
    swig_globalvar *var = v->vars;
    while (var) {
      swig_globalvar *n = var->next;
      free(var->name);
      free(var);
      var = n;
    }
  }
  
  SWIGINTERN PyObject *
  swig_varlink_getattr(swig_varlinkobject *v, char *n) {
    PyObject *res = NULL;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->get_attr)();
        break;
      }
      var = var->next;
    }
    if (res == NULL && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN int
  swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
    int res = 1;
    swig_globalvar *var = v->vars;
    while (var) {
      if (strcmp(var->name,n) == 0) {
        res = (*var->set_attr)(p);
        break;
      }
      var = var->next;
    }
    if (res == 1 && !PyErr_Occurred()) {
      PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
    }
    return res;
  }
  
  SWIGINTERN PyTypeObject*
  swig_varlink_type(void) {
    static char varlink__doc__[] = "Swig var link object";
    static PyTypeObject varlink_type;
    static int type_init = 0;
    if (!type_init) {
      const PyTypeObject tmp = {
#if PY_VERSION_HEX >= 0x03000000
        PyVarObject_HEAD_INIT(NULL, 0)
#else
        PyObject_HEAD_INIT(NULL)
        0,                                  /* ob_size */
#endif
        "swigvarlink",                      /* tp_name */
        sizeof(swig_varlinkobject),         /* tp_basicsize */
        0,                                  /* tp_itemsize */
        (destructor) swig_varlink_dealloc,  /* tp_dealloc */
        0,                                  /* tp_print */
        (getattrfunc) swig_varlink_getattr, /* tp_getattr */
        (setattrfunc) swig_varlink_setattr, /* tp_setattr */
        0,                                  /* tp_compare */
        (reprfunc) swig_varlink_repr,       /* tp_repr */
        0,                                  /* tp_as_number */
        0,                                  /* tp_as_sequence */
        0,                                  /* tp_as_mapping */
        0,                                  /* tp_hash */
        0,                                  /* tp_call */
        (reprfunc) swig_varlink_str,        /* tp_str */
        0,                                  /* tp_getattro */
        0,                                  /* tp_setattro */
        0,                                  /* tp_as_buffer */
        0,                                  /* tp_flags */
        varlink__doc__,                     /* tp_doc */
        0,                                  /* tp_traverse */
        0,                                  /* tp_clear */
        0,                                  /* tp_richcompare */
        0,                                  /* tp_weaklistoffset */
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
        0,                                  /* tp_del */
        0,                                  /* tp_version_tag */
#if PY_VERSION_HEX >= 0x03040000
        0,                                  /* tp_finalize */
#endif
#ifdef COUNT_ALLOCS
        0,                                  /* tp_allocs */
        0,                                  /* tp_frees */
        0,                                  /* tp_maxalloc */
        0,                                  /* tp_prev */
        0                                   /* tp_next */
#endif
      };
      varlink_type = tmp;
      type_init = 1;
      if (PyType_Ready(&varlink_type) < 0)
      return NULL;
    }
    return &varlink_type;
  }
  
  /* Create a variable linking object for use later */
  SWIGINTERN PyObject *
  SWIG_Python_newvarlink(void) {
    swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
    if (result) {
      result->vars = 0;
    }
    return ((PyObject*) result);
  }
  
  SWIGINTERN void 
  SWIG_Python_addvarlink(PyObject *p, const char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
    swig_varlinkobject *v = (swig_varlinkobject *) p;
    swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
    if (gv) {
      size_t size = strlen(name)+1;
      gv->name = (char *)malloc(size);
      if (gv->name) {
        memcpy(gv->name, name, size);
        gv->get_attr = get_attr;
        gv->set_attr = set_attr;
        gv->next = v->vars;
      }
    }
    v->vars = gv;
  }
  
  SWIGINTERN PyObject *
  SWIG_globals(void) {
    static PyObject *globals = 0;
    if (!globals) {
      globals = SWIG_newvarlink();
    }
    return globals;
  }
  
  /* -----------------------------------------------------------------------------
   * constants/methods manipulation
   * ----------------------------------------------------------------------------- */
  
  /* Install Constants */
  SWIGINTERN void
  SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
    PyObject *obj = 0;
    size_t i;
    for (i = 0; constants[i].type; ++i) {
      switch(constants[i].type) {
      case SWIG_PY_POINTER:
        obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
        break;
      case SWIG_PY_BINARY:
        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
        break;
      default:
        obj = 0;
        break;
      }
      if (obj) {
        PyDict_SetItemString(d, constants[i].name, obj);
        Py_DECREF(obj);
      }
    }
  }
  
  /* -----------------------------------------------------------------------------*/
  /* Fix SwigMethods to carry the callback ptrs when needed */
  /* -----------------------------------------------------------------------------*/
  
  SWIGINTERN void
  SWIG_Python_FixMethods(PyMethodDef *methods,
    swig_const_info *const_table,
    swig_type_info **types,
    swig_type_info **types_initial) {
    size_t i;
    for (i = 0; methods[i].ml_name; ++i) {
      const char *c = methods[i].ml_doc;
      if (!c) continue;
      c = strstr(c, "swig_ptr: ");
      if (c) {
        int j;
        swig_const_info *ci = 0;
        const char *name = c + 10;
        for (j = 0; const_table[j].type; ++j) {
          if (strncmp(const_table[j].name, name, 
              strlen(const_table[j].name)) == 0) {
            ci = &(const_table[j]);
            break;
          }
        }
        if (ci) {
          void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
          if (ptr) {
            size_t shift = (ci->ptype) - types;
            swig_type_info *ty = types_initial[shift];
            size_t ldoc = (c - methods[i].ml_doc);
            size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
            char *ndoc = (char*)malloc(ldoc + lptr + 10);
            if (ndoc) {
              char *buff = ndoc;
              memcpy(buff, methods[i].ml_doc, ldoc);
              buff += ldoc;
              memcpy(buff, "swig_ptr: ", 10);
              buff += 10;
              SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
              methods[i].ml_doc = ndoc;
            }
          }
        }
      }
    }
  } 
  
  /* -----------------------------------------------------------------------------
   * Method creation and docstring support functions
   * ----------------------------------------------------------------------------- */
  
  /* -----------------------------------------------------------------------------
   * Function to find the method definition with the correct docstring for the
   * proxy module as opposed to the low-level API
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyMethodDef *SWIG_PythonGetProxyDoc(const char *name) {
    /* Find the function in the modified method table */
    size_t offset = 0;
    int found = 0;
    while (SwigMethods_proxydocs[offset].ml_meth != NULL) {
      if (strcmp(SwigMethods_proxydocs[offset].ml_name, name) == 0) {
        found = 1;
        break;
      }
      offset++;
    }
    /* Use the copy with the modified docstring if available */
    return found ? &SwigMethods_proxydocs[offset] : NULL;
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyInstanceMethod_New() used in Python 3
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
#if PY_VERSION_HEX >= 0x03000000
    return PyInstanceMethod_New(func);
#else
    return PyMethod_New(func, NULL, NULL);
#endif
  }
  
  /* -----------------------------------------------------------------------------
   * Wrapper of PyStaticMethod_New()
   * It is exported to the generated module, used for -fastproxy
   * ----------------------------------------------------------------------------- */
  
  SWIGINTERN PyObject *SWIG_PyStaticMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func) {
    if (PyCFunction_Check(func)) {
      PyCFunctionObject *funcobj = (PyCFunctionObject *)func;
      PyMethodDef *ml = SWIG_PythonGetProxyDoc(funcobj->m_ml->ml_name);
      if (ml)
      func = PyCFunction_NewEx(ml, funcobj->m_self, funcobj->m_module);
    }
    return PyStaticMethod_New(func);
  }
  
#ifdef __cplusplus
}
#endif

/* -----------------------------------------------------------------------------*
 *  Partial Init method
 * -----------------------------------------------------------------------------*/

#ifdef __cplusplus
extern "C"
#endif

SWIGEXPORT 
#if PY_VERSION_HEX >= 0x03000000
PyObject*
#else
void
#endif
SWIG_init(void) {
  PyObject *m, *d, *md, *globals;
  
#if PY_VERSION_HEX >= 0x03000000
  static struct PyModuleDef SWIG_module = {
    PyModuleDef_HEAD_INIT,
    SWIG_name,
    NULL,
    -1,
    SwigMethods,
    NULL,
    NULL,
    NULL,
    NULL
  };
#endif
  
#if defined(SWIGPYTHON_BUILTIN)
  static SwigPyClientData SwigPyObject_clientdata = {
    0, 0, 0, 0, 0, 0, 0
  };
  static PyGetSetDef this_getset_def = {
    (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
  };
  static SwigPyGetSet thisown_getset_closure = {
    SwigPyObject_own,
    SwigPyObject_own
  };
  static PyGetSetDef thisown_getset_def = {
    (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
  };
  PyTypeObject *builtin_pytype;
  int builtin_base_count;
  swig_type_info *builtin_basetype;
  PyObject *tuple;
  PyGetSetDescrObject *static_getset;
  PyTypeObject *metatype;
  PyTypeObject *swigpyobject;
  SwigPyClientData *cd;
  PyObject *public_interface, *public_symbol;
  PyObject *this_descr;
  PyObject *thisown_descr;
  PyObject *self = 0;
  int i;
  
  (void)builtin_pytype;
  (void)builtin_base_count;
  (void)builtin_basetype;
  (void)tuple;
  (void)static_getset;
  (void)self;
  
  /* Metaclass is used to implement static member variables */
  metatype = SwigPyObjectType();
  assert(metatype);
#endif
  
  (void)globals;
  
  /* Create singletons now to avoid potential deadlocks with multi-threaded usage after module initialization */
  SWIG_This();
  SWIG_Python_TypeCache();
  SwigPyPacked_type();
#ifndef SWIGPYTHON_BUILTIN
  SwigPyObject_type();
#endif
  
  /* Fix SwigMethods to carry the callback ptrs when needed */
  SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
  
#if PY_VERSION_HEX >= 0x03000000
  m = PyModule_Create(&SWIG_module);
#else
  m = Py_InitModule(SWIG_name, SwigMethods);
#endif
  
  md = d = PyModule_GetDict(m);
  (void)md;
  
  SWIG_InitializeModule(0);
  
#ifdef SWIGPYTHON_BUILTIN
  swigpyobject = SwigPyObject_TypeOnce();
  
  SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
  assert(SwigPyObject_stype);
  cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
  if (!cd) {
    SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
    SwigPyObject_clientdata.pytype = swigpyobject;
  } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
    PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
# if PY_VERSION_HEX >= 0x03000000
    return NULL;
# else
    return;
# endif
  }
  
  /* All objects have a 'this' attribute */
  this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
  (void)this_descr;
  
  /* All objects have a 'thisown' attribute */
  thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
  (void)thisown_descr;
  
  public_interface = PyList_New(0);
  public_symbol = 0;
  (void)public_symbol;
  
  PyDict_SetItemString(md, "__all__", public_interface);
  Py_DECREF(public_interface);
  for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
  for (i = 0; swig_const_table[i].name != 0; ++i)
  SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
#endif
  
  SWIG_InstallConstants(d,swig_const_table);
  
  
  import_array(); /* For numpy interface */
  erract_c("SET", 256, "RETURN");
  errdev_c("SET", 256, "NULL");   /* Suppresses default error messages */
  initialize_typemap_globals();
  
#if PY_VERSION_HEX >= 0x03000000
  return m;
#else
  return;
#endif
}

