Context Navigation

shtns_numpy_wrap.c

main

Last change on this file was ea777aa, checked in by Alex Wilton <awilton@…>, 3 years ago

Moved examples, include, build_default.properties, common.xml, and README out from dev.civl.com into the root of the repo.

git-svn-id: svn://vsl.cis.udel.edu/civl/trunk@5704 fb995dde-84ed-4084-dfe6-e5aef3e2452c

Property mode set to 100644

File size: 202.6 KB

Rev	Line
[2131108]	1	/* ----------------------------------------------------------------------------
	2	* This file was automatically generated by SWIG (http://www.swig.org).
	3	* Version 3.0.5
	4	*
	5	* This file is not intended to be easily readable and contains a number of
	6	* coding conventions designed to improve portability and efficiency. Do not make
	7	* changes to this file unless you know what you are doing--modify the SWIG
	8	* interface file instead.
	9	* ----------------------------------------------------------------------------- */
	10
	11	#define SWIGPYTHON
	12	#define SWIG_PYTHON_DIRECTOR_NO_VTABLE
	13
	14	/* -----------------------------------------------------------------------------
	15	* This section contains generic SWIG labels for method/variable
	16	* declarations/attributes, and other compiler dependent labels.
	17	* ----------------------------------------------------------------------------- */
	18
	19	/* template workaround for compilers that cannot correctly implement the C++ standard */
	20	#ifndef SWIGTEMPLATEDISAMBIGUATOR
	21	# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
	22	# define SWIGTEMPLATEDISAMBIGUATOR template
	23	# elif defined(__HP_aCC)
	24	/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
	25	/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
	26	# define SWIGTEMPLATEDISAMBIGUATOR template
	27	# else
	28	# define SWIGTEMPLATEDISAMBIGUATOR
	29	# endif
	30	#endif
	31
	32	/* inline attribute */
	33	#ifndef SWIGINLINE
	34	# if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
	35	# define SWIGINLINE inline
	36	# else
	37	# define SWIGINLINE
	38	# endif
	39	#endif
	40
	41	/* attribute recognised by some compilers to avoid 'unused' warnings */
	42	#ifndef SWIGUNUSED
	43	# if defined(__GNUC__)
	44	# if !(defined(__cplusplus)) \|\| (__GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
	45	# define SWIGUNUSED __attribute__ ((__unused__))
	46	# else
	47	# define SWIGUNUSED
	48	# endif
	49	# elif defined(__ICC)
	50	# define SWIGUNUSED __attribute__ ((__unused__))
	51	# else
	52	# define SWIGUNUSED
	53	# endif
	54	#endif
	55
	56	#ifndef SWIG_MSC_UNSUPPRESS_4505
	57	# if defined(_MSC_VER)
	58	# pragma warning(disable : 4505) /* unreferenced local function has been removed */
	59	# endif
	60	#endif
	61
	62	#ifndef SWIGUNUSEDPARM
	63	# ifdef __cplusplus
	64	# define SWIGUNUSEDPARM(p)
	65	# else
	66	# define SWIGUNUSEDPARM(p) p SWIGUNUSED
	67	# endif
	68	#endif
	69
	70	/* internal SWIG method */
	71	#ifndef SWIGINTERN
	72	# define SWIGINTERN static SWIGUNUSED
	73	#endif
	74
	75	/* internal inline SWIG method */
	76	#ifndef SWIGINTERNINLINE
	77	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
	78	#endif
	79
	80	/* exporting methods */
	81	#if (__GNUC__ >= 4) \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
	82	# ifndef GCC_HASCLASSVISIBILITY
	83	# define GCC_HASCLASSVISIBILITY
	84	# endif
	85	#endif
	86
	87	#ifndef SWIGEXPORT
	88	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
	89	# if defined(STATIC_LINKED)
	90	# define SWIGEXPORT
	91	# else
	92	# define SWIGEXPORT __declspec(dllexport)
	93	# endif
	94	# else
	95	# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
	96	# define SWIGEXPORT __attribute__ ((visibility("default")))
	97	# else
	98	# define SWIGEXPORT
	99	# endif
	100	# endif
	101	#endif
	102
	103	/* calling conventions for Windows */
	104	#ifndef SWIGSTDCALL
	105	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
	106	# define SWIGSTDCALL __stdcall
	107	# else
	108	# define SWIGSTDCALL
	109	# endif
	110	#endif
	111
	112	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
	113	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
	114	# define _CRT_SECURE_NO_DEPRECATE
	115	#endif
	116
	117	/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
	118	#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
	119	# define _SCL_SECURE_NO_DEPRECATE
	120	#endif
	121
	122
	123
	124	#if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
	125	/* Use debug wrappers with the Python release dll */
	126	# undef _DEBUG
	127	# include <Python.h>
	128	# define _DEBUG
	129	#else
	130	# include <Python.h>
	131	#endif
	132
	133	/* -----------------------------------------------------------------------------
	134	* swigrun.swg
	135	*
	136	* This file contains generic C API SWIG runtime support for pointer
	137	* type checking.
	138	* ----------------------------------------------------------------------------- */
	139
	140	/* This should only be incremented when either the layout of swig_type_info changes,
	141	or for whatever reason, the runtime changes incompatibly */
	142	#define SWIG_RUNTIME_VERSION "4"
	143
	144	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
	145	#ifdef SWIG_TYPE_TABLE
	146	# define SWIG_QUOTE_STRING(x) #x
	147	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
	148	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
	149	#else
	150	# define SWIG_TYPE_TABLE_NAME
	151	#endif
	152
	153	/*
	154	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
	155	creating a static or dynamic library from the SWIG runtime code.
	156	In 99.9% of the cases, SWIG just needs to declare them as 'static'.
	157
	158	But only do this if strictly necessary, ie, if you have problems
	159	with your compiler or suchlike.
	160	*/
	161
	162	#ifndef SWIGRUNTIME
	163	# define SWIGRUNTIME SWIGINTERN
	164	#endif
	165
	166	#ifndef SWIGRUNTIMEINLINE
	167	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
	168	#endif
	169
	170	/* Generic buffer size */
	171	#ifndef SWIG_BUFFER_SIZE
	172	# define SWIG_BUFFER_SIZE 1024
	173	#endif
	174
	175	/* Flags for pointer conversions */
	176	#define SWIG_POINTER_DISOWN 0x1
	177	#define SWIG_CAST_NEW_MEMORY 0x2
	178
	179	/* Flags for new pointer objects */
	180	#define SWIG_POINTER_OWN 0x1
	181
	182
	183	/*
	184	Flags/methods for returning states.
	185
	186	The SWIG conversion methods, as ConvertPtr, return an integer
	187	that tells if the conversion was successful or not. And if not,
	188	an error code can be returned (see swigerrors.swg for the codes).
	189
	190	Use the following macros/flags to set or process the returning
	191	states.
	192
	193	In old versions of SWIG, code such as the following was usually written:
	194
	195	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
	196	// success code
	197	} else {
	198	//fail code
	199	}
	200
	201	Now you can be more explicit:
	202
	203	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
	204	if (SWIG_IsOK(res)) {
	205	// success code
	206	} else {
	207	// fail code
	208	}
	209
	210	which is the same really, but now you can also do
	211
	212	Type *ptr;
	213	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
	214	if (SWIG_IsOK(res)) {
	215	// success code
	216	if (SWIG_IsNewObj(res) {
	217	...
	218	delete *ptr;
	219	} else {
	220	...
	221	}
	222	} else {
	223	// fail code
	224	}
	225
	226	I.e., now SWIG_ConvertPtr can return new objects and you can
	227	identify the case and take care of the deallocation. Of course that
	228	also requires SWIG_ConvertPtr to return new result values, such as
	229
	230	int SWIG_ConvertPtr(obj, ptr,...) {
	231	if (<obj is ok>) {
	232	if (<need new object>) {
	233	*ptr = <ptr to new allocated object>;
	234	return SWIG_NEWOBJ;
	235	} else {
	236	*ptr = <ptr to old object>;
	237	return SWIG_OLDOBJ;
	238	}
	239	} else {
	240	return SWIG_BADOBJ;
	241	}
	242	}
	243
	244	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
	245	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
	246	SWIG errors code.
	247
	248	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
	249	allows to return the 'cast rank', for example, if you have this
	250
	251	int food(double)
	252	int fooi(int);
	253
	254	and you call
	255
	256	food(1) // cast rank '1' (1 -> 1.0)
	257	fooi(1) // cast rank '0'
	258
	259	just use the SWIG_AddCast()/SWIG_CheckState()
	260	*/
	261
	262	#define SWIG_OK (0)
	263	#define SWIG_ERROR (-1)
	264	#define SWIG_IsOK(r) (r >= 0)
	265	#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
	266
	267	/* The CastRankLimit says how many bits are used for the cast rank */
	268	#define SWIG_CASTRANKLIMIT (1 << 8)
	269	/* The NewMask denotes the object was created (using new/malloc) */
	270	#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
	271	/* The TmpMask is for in/out typemaps that use temporal objects */
	272	#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
	273	/* Simple returning values */
	274	#define SWIG_BADOBJ (SWIG_ERROR)
	275	#define SWIG_OLDOBJ (SWIG_OK)
	276	#define SWIG_NEWOBJ (SWIG_OK \| SWIG_NEWOBJMASK)
	277	#define SWIG_TMPOBJ (SWIG_OK \| SWIG_TMPOBJMASK)
	278	/* Check, add and del mask methods */
	279	#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r \| SWIG_NEWOBJMASK) : r)
	280	#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
	281	#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
	282	#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r \| SWIG_TMPOBJMASK) : r)
	283	#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
	284	#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
	285
	286	/* Cast-Rank Mode */
	287	#if defined(SWIG_CASTRANK_MODE)
	288	# ifndef SWIG_TypeRank
	289	# define SWIG_TypeRank unsigned long
	290	# endif
	291	# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
	292	# define SWIG_MAXCASTRANK (2)
	293	# endif
	294	# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
	295	# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
	296	SWIGINTERNINLINE int SWIG_AddCast(int r) {
	297	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
	298	}
	299	SWIGINTERNINLINE int SWIG_CheckState(int r) {
	300	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
	301	}
	302	#else /* no cast-rank mode */
	303	# define SWIG_AddCast(r) (r)
	304	# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
	305	#endif
	306
	307
	308	#include <string.h>
	309
	310	#ifdef __cplusplus
	311	extern "C" {
	312	#endif
	313
	314	typedef void (swig_converter_func)(void , int );
	315	typedef struct swig_type_info (swig_dycast_func)(void **);
	316
	317	/* Structure to store information on one type */
	318	typedef struct swig_type_info {
	319	const char name; / mangled name of this type */
	320	const char str; / human readable name of this type */
	321	swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
	322	struct swig_cast_info cast; / linked list of types that can cast into this type */
	323	void clientdata; / language specific type data */
	324	int owndata; /* flag if the structure owns the clientdata */
	325	} swig_type_info;
	326
	327	/* Structure to store a type and conversion function used for casting */
	328	typedef struct swig_cast_info {
	329	swig_type_info type; / pointer to type that is equivalent to this type */
	330	swig_converter_func converter; /* function to cast the void pointers */
	331	struct swig_cast_info next; / pointer to next cast in linked list */
	332	struct swig_cast_info prev; / pointer to the previous cast */
	333	} swig_cast_info;
	334
	335	/* Structure used to store module information
	336	* Each module generates one structure like this, and the runtime collects
	337	* all of these structures and stores them in a circularly linked list.*/
	338	typedef struct swig_module_info {
	339	swig_type_info *types; / Array of pointers to swig_type_info structures that are in this module */
	340	size_t size; /* Number of types in this module */
	341	struct swig_module_info next; / Pointer to next element in circularly linked list */
	342	swig_type_info *type_initial; / Array of initially generated type structures */
	343	swig_cast_info *cast_initial; / Array of initially generated casting structures */
	344	void clientdata; / Language specific module data */
	345	} swig_module_info;
	346
	347	/*
	348	Compare two type names skipping the space characters, therefore
	349	"char" == "char " and "Class<int>" == "Class<int >", etc.
	350
	351	Return 0 when the two name types are equivalent, as in
	352	strncmp, but skipping ' '.
	353	*/
	354	SWIGRUNTIME int
	355	SWIG_TypeNameComp(const char f1, const char l1,
	356	const char f2, const char l2) {
	357	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
	358	while ((*f1 == ' ') && (f1 != l1)) ++f1;
	359	while ((*f2 == ' ') && (f2 != l2)) ++f2;
	360	if (f1 != f2) return (f1 > f2) ? 1 : -1;
	361	}
	362	return (int)((l1 - f1) - (l2 - f2));
	363	}
	364
	365	/*
	366	Check type equivalence in a name list like <name1>\|<name2>\|...
	367	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
	368	*/
	369	SWIGRUNTIME int
	370	SWIG_TypeCmp(const char nb, const char tb) {
	371	int equiv = 1;
	372	const char* te = tb + strlen(tb);
	373	const char* ne = nb;
	374	while (equiv != 0 && *ne) {
	375	for (nb = ne; *ne; ++ne) {
	376	if (*ne == '\|') break;
	377	}
	378	equiv = SWIG_TypeNameComp(nb, ne, tb, te);
	379	if (*ne) ++ne;
	380	}
	381	return equiv;
	382	}
	383
	384	/*
	385	Check type equivalence in a name list like <name1>\|<name2>\|...
	386	Return 0 if not equal, 1 if equal
	387	*/
	388	SWIGRUNTIME int
	389	SWIG_TypeEquiv(const char nb, const char tb) {
	390	return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
	391	}
	392
	393	/*
	394	Check the typename
	395	*/
	396	SWIGRUNTIME swig_cast_info *
	397	SWIG_TypeCheck(const char c, swig_type_info ty) {
	398	if (ty) {
	399	swig_cast_info *iter = ty->cast;
	400	while (iter) {
	401	if (strcmp(iter->type->name, c) == 0) {
	402	if (iter == ty->cast)
	403	return iter;
	404	/* Move iter to the top of the linked list */
	405	iter->prev->next = iter->next;
	406	if (iter->next)
	407	iter->next->prev = iter->prev;
	408	iter->next = ty->cast;
	409	iter->prev = 0;
	410	if (ty->cast) ty->cast->prev = iter;
	411	ty->cast = iter;
	412	return iter;
	413	}
	414	iter = iter->next;
	415	}
	416	}
	417	return 0;
	418	}
	419
	420	/*
	421	Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
	422	*/
	423	SWIGRUNTIME swig_cast_info *
	424	SWIG_TypeCheckStruct(swig_type_info from, swig_type_info ty) {
	425	if (ty) {
	426	swig_cast_info *iter = ty->cast;
	427	while (iter) {
	428	if (iter->type == from) {
	429	if (iter == ty->cast)
	430	return iter;
	431	/* Move iter to the top of the linked list */
	432	iter->prev->next = iter->next;
	433	if (iter->next)
	434	iter->next->prev = iter->prev;
	435	iter->next = ty->cast;
	436	iter->prev = 0;
	437	if (ty->cast) ty->cast->prev = iter;
	438	ty->cast = iter;
	439	return iter;
	440	}
	441	iter = iter->next;
	442	}
	443	}
	444	return 0;
	445	}
	446
	447	/*
	448	Cast a pointer up an inheritance hierarchy
	449	*/
	450	SWIGRUNTIMEINLINE void *
	451	SWIG_TypeCast(swig_cast_info ty, void ptr, int *newmemory) {
	452	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
	453	}
	454
	455	/*
	456	Dynamic pointer casting. Down an inheritance hierarchy
	457	*/
	458	SWIGRUNTIME swig_type_info *
	459	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
	460	swig_type_info *lastty = ty;
	461	if (!ty \|\| !ty->dcast) return ty;
	462	while (ty && (ty->dcast)) {
	463	ty = (*ty->dcast)(ptr);
	464	if (ty) lastty = ty;
	465	}
	466	return lastty;
	467	}
	468
	469	/*
	470	Return the name associated with this type
	471	*/
	472	SWIGRUNTIMEINLINE const char *
	473	SWIG_TypeName(const swig_type_info *ty) {
	474	return ty->name;
	475	}
	476
	477	/*
	478	Return the pretty name associated with this type,
	479	that is an unmangled type name in a form presentable to the user.
	480	*/
	481	SWIGRUNTIME const char *
	482	SWIG_TypePrettyName(const swig_type_info *type) {
	483	/* The "str" field contains the equivalent pretty names of the
	484	type, separated by vertical-bar characters. We choose
	485	to print the last name, as it is often (?) the most
	486	specific. */
	487	if (!type) return NULL;
	488	if (type->str != NULL) {
	489	const char *last_name = type->str;
	490	const char *s;
	491	for (s = type->str; *s; s++)
	492	if (*s == '\|') last_name = s+1;
	493	return last_name;
	494	}
	495	else
	496	return type->name;
	497	}
	498
	499	/*
	500	Set the clientdata field for a type
	501	*/
	502	SWIGRUNTIME void
	503	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
	504	swig_cast_info *cast = ti->cast;
	505	/* if (ti->clientdata == clientdata) return; */
	506	ti->clientdata = clientdata;
	507
	508	while (cast) {
	509	if (!cast->converter) {
	510	swig_type_info *tc = cast->type;
	511	if (!tc->clientdata) {
	512	SWIG_TypeClientData(tc, clientdata);
	513	}
	514	}
	515	cast = cast->next;
	516	}
	517	}
	518	SWIGRUNTIME void
	519	SWIG_TypeNewClientData(swig_type_info ti, void clientdata) {
	520	SWIG_TypeClientData(ti, clientdata);
	521	ti->owndata = 1;
	522	}
	523
	524	/*
	525	Search for a swig_type_info structure only by mangled name
	526	Search is a O(log #types)
	527
	528	We start searching at module start, and finish searching when start == end.
	529	Note: if start == end at the beginning of the function, we go all the way around
	530	the circular list.
	531	*/
	532	SWIGRUNTIME swig_type_info *
	533	SWIG_MangledTypeQueryModule(swig_module_info *start,
	534	swig_module_info *end,
	535	const char *name) {
	536	swig_module_info *iter = start;
	537	do {
	538	if (iter->size) {
	539	size_t l = 0;
	540	size_t r = iter->size - 1;
	541	do {
	542	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
	543	size_t i = (l + r) >> 1;
	544	const char *iname = iter->types[i]->name;
	545	if (iname) {
	546	int compare = strcmp(name, iname);
	547	if (compare == 0) {
	548	return iter->types[i];
	549	} else if (compare < 0) {
	550	if (i) {
	551	r = i - 1;
	552	} else {
	553	break;
	554	}
	555	} else if (compare > 0) {
	556	l = i + 1;
	557	}
	558	} else {
	559	break; /* should never happen */
	560	}
	561	} while (l <= r);
	562	}
	563	iter = iter->next;
	564	} while (iter != end);
	565	return 0;
	566	}
	567
	568	/*
	569	Search for a swig_type_info structure for either a mangled name or a human readable name.
	570	It first searches the mangled names of the types, which is a O(log #types)
	571	If a type is not found it then searches the human readable names, which is O(#types).
	572
	573	We start searching at module start, and finish searching when start == end.
	574	Note: if start == end at the beginning of the function, we go all the way around
	575	the circular list.
	576	*/
	577	SWIGRUNTIME swig_type_info *
	578	SWIG_TypeQueryModule(swig_module_info *start,
	579	swig_module_info *end,
	580	const char *name) {
	581	/* STEP 1: Search the name field using binary search */
	582	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
	583	if (ret) {
	584	return ret;
	585	} else {
	586	/* STEP 2: If the type hasn't been found, do a complete search
	587	of the str field (the human readable name) */
	588	swig_module_info *iter = start;
	589	do {
	590	size_t i = 0;
	591	for (; i < iter->size; ++i) {
	592	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
	593	return iter->types[i];
	594	}
	595	iter = iter->next;
	596	} while (iter != end);
	597	}
	598
	599	/* neither found a match */
	600	return 0;
	601	}
	602
	603	/*
	604	Pack binary data into a string
	605	*/
	606	SWIGRUNTIME char *
	607	SWIG_PackData(char c, void ptr, size_t sz) {
	608	static const char hex[17] = "0123456789abcdef";
	609	const unsigned char u = (unsigned char ) ptr;
	610	const unsigned char *eu = u + sz;
	611	for (; u != eu; ++u) {
	612	unsigned char uu = *u;
	613	*(c++) = hex[(uu & 0xf0) >> 4];
	614	*(c++) = hex[uu & 0xf];
	615	}
	616	return c;
	617	}
	618
	619	/*
	620	Unpack binary data from a string
	621	*/
	622	SWIGRUNTIME const char *
	623	SWIG_UnpackData(const char c, void ptr, size_t sz) {
	624	unsigned char u = (unsigned char ) ptr;
	625	const unsigned char *eu = u + sz;
	626	for (; u != eu; ++u) {
	627	char d = *(c++);
	628	unsigned char uu;
	629	if ((d >= '0') && (d <= '9'))
	630	uu = ((d - '0') << 4);
	631	else if ((d >= 'a') && (d <= 'f'))
	632	uu = ((d - ('a'-10)) << 4);
	633	else
	634	return (char *) 0;
	635	d = *(c++);
	636	if ((d >= '0') && (d <= '9'))
	637	uu \|= (d - '0');
	638	else if ((d >= 'a') && (d <= 'f'))
	639	uu \|= (d - ('a'-10));
	640	else
	641	return (char *) 0;
	642	*u = uu;
	643	}
	644	return c;
	645	}
	646
	647	/*
	648	Pack 'void *' into a string buffer.
	649	*/
	650	SWIGRUNTIME char *
	651	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
	652	char *r = buff;
	653	if ((2sizeof(void ) + 2) > bsz) return 0;
	654	*(r++) = '_';
	655	r = SWIG_PackData(r,&ptr,sizeof(void *));
	656	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
	657	strcpy(r,name);
	658	return buff;
	659	}
	660
	661	SWIGRUNTIME const char *
	662	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
	663	if (*c != '_') {
	664	if (strcmp(c,"NULL") == 0) {
	665	ptr = (void ) 0;
	666	return name;
	667	} else {
	668	return 0;
	669	}
	670	}
	671	return SWIG_UnpackData(++c,ptr,sizeof(void *));
	672	}
	673
	674	SWIGRUNTIME char *
	675	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
	676	char *r = buff;
	677	size_t lname = (name ? strlen(name) : 0);
	678	if ((2*sz + 2 + lname) > bsz) return 0;
	679	*(r++) = '_';
	680	r = SWIG_PackData(r,ptr,sz);
	681	if (lname) {
	682	strncpy(r,name,lname+1);
	683	} else {
	684	*r = 0;
	685	}
	686	return buff;
	687	}
	688
	689	SWIGRUNTIME const char *
	690	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
	691	if (*c != '_') {
	692	if (strcmp(c,"NULL") == 0) {
	693	memset(ptr,0,sz);
	694	return name;
	695	} else {
	696	return 0;
	697	}
	698	}
	699	return SWIG_UnpackData(++c,ptr,sz);
	700	}
	701
	702	#ifdef __cplusplus
	703	}
	704	#endif
	705
	706	/* Errors in SWIG */
	707	#define SWIG_UnknownError -1
	708	#define SWIG_IOError -2
	709	#define SWIG_RuntimeError -3
	710	#define SWIG_IndexError -4
	711	#define SWIG_TypeError -5
	712	#define SWIG_DivisionByZero -6
	713	#define SWIG_OverflowError -7
	714	#define SWIG_SyntaxError -8
	715	#define SWIG_ValueError -9
	716	#define SWIG_SystemError -10
	717	#define SWIG_AttributeError -11
	718	#define SWIG_MemoryError -12
	719	#define SWIG_NullReferenceError -13
	720
	721
	722
	723	/* Compatibility macros for Python 3 */
	724	#if PY_VERSION_HEX >= 0x03000000
	725
	726	#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
	727	#define PyInt_Check(x) PyLong_Check(x)
	728	#define PyInt_AsLong(x) PyLong_AsLong(x)
	729	#define PyInt_FromLong(x) PyLong_FromLong(x)
	730	#define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
	731	#define PyString_Check(name) PyBytes_Check(name)
	732	#define PyString_FromString(x) PyUnicode_FromString(x)
	733	#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
	734	#define PyString_AsString(str) PyBytes_AsString(str)
	735	#define PyString_Size(str) PyBytes_Size(str)
	736	#define PyString_InternFromString(key) PyUnicode_InternFromString(key)
	737	#define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
	738	#define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
	739	#define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
	740
	741	#endif
	742
	743	#ifndef Py_TYPE
	744	# define Py_TYPE(op) ((op)->ob_type)
	745	#endif
	746
	747	/* SWIG APIs for compatibility of both Python 2 & 3 */
	748
	749	#if PY_VERSION_HEX >= 0x03000000
	750	# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
	751	#else
	752	# define SWIG_Python_str_FromFormat PyString_FromFormat
	753	#endif
	754
	755
	756	/* Warning: This function will allocate a new string in Python 3,
	757	* so please call SWIG_Python_str_DelForPy3(x) to free the space.
	758	*/
	759	SWIGINTERN char*
	760	SWIG_Python_str_AsChar(PyObject *str)
	761	{
	762	#if PY_VERSION_HEX >= 0x03000000
	763	char *cstr;
	764	char *newstr;
	765	Py_ssize_t len;
	766	str = PyUnicode_AsUTF8String(str);
	767	PyBytes_AsStringAndSize(str, &cstr, &len);
	768	newstr = (char *) malloc(len+1);
	769	memcpy(newstr, cstr, len+1);
	770	Py_XDECREF(str);
	771	return newstr;
	772	#else
	773	return PyString_AsString(str);
	774	#endif
	775	}
	776
	777	#if PY_VERSION_HEX >= 0x03000000
	778	# define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
	779	#else
	780	# define SWIG_Python_str_DelForPy3(x)
	781	#endif
	782
	783
	784	SWIGINTERN PyObject*
	785	SWIG_Python_str_FromChar(const char *c)
	786	{
	787	#if PY_VERSION_HEX >= 0x03000000
	788	return PyUnicode_FromString(c);
	789	#else
	790	return PyString_FromString(c);
	791	#endif
	792	}
	793
	794	/* Add PyOS_snprintf for old Pythons */
	795	#if PY_VERSION_HEX < 0x02020000
	796	# if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(_WATCOM)
	797	# define PyOS_snprintf _snprintf
	798	# else
	799	# define PyOS_snprintf snprintf
	800	# endif
	801	#endif
	802
	803	/* A crude PyString_FromFormat implementation for old Pythons */
	804	#if PY_VERSION_HEX < 0x02020000
	805
	806	#ifndef SWIG_PYBUFFER_SIZE
	807	# define SWIG_PYBUFFER_SIZE 1024
	808	#endif
	809
	810	static PyObject *
	811	PyString_FromFormat(const char *fmt, ...) {
	812	va_list ap;
	813	char buf[SWIG_PYBUFFER_SIZE * 2];
	814	int res;
	815	va_start(ap, fmt);
	816	res = vsnprintf(buf, sizeof(buf), fmt, ap);
	817	va_end(ap);
	818	return (res < 0 \|\| res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
	819	}
	820	#endif
	821
	822	/* Add PyObject_Del for old Pythons */
	823	#if PY_VERSION_HEX < 0x01060000
	824	# define PyObject_Del(op) PyMem_DEL((op))
	825	#endif
	826	#ifndef PyObject_DEL
	827	# define PyObject_DEL PyObject_Del
	828	#endif
	829
	830	/* A crude PyExc_StopIteration exception for old Pythons */
	831	#if PY_VERSION_HEX < 0x02020000
	832	# ifndef PyExc_StopIteration
	833	# define PyExc_StopIteration PyExc_RuntimeError
	834	# endif
	835	# ifndef PyObject_GenericGetAttr
	836	# define PyObject_GenericGetAttr 0
	837	# endif
	838	#endif
	839
	840	/* Py_NotImplemented is defined in 2.1 and up. */
	841	#if PY_VERSION_HEX < 0x02010000
	842	# ifndef Py_NotImplemented
	843	# define Py_NotImplemented PyExc_RuntimeError
	844	# endif
	845	#endif
	846
	847	/* A crude PyString_AsStringAndSize implementation for old Pythons */
	848	#if PY_VERSION_HEX < 0x02010000
	849	# ifndef PyString_AsStringAndSize
	850	# define PyString_AsStringAndSize(obj, s, len) {s = PyString_AsString(obj); len = s ? strlen(s) : 0;}
	851	# endif
	852	#endif
	853
	854	/* PySequence_Size for old Pythons */
	855	#if PY_VERSION_HEX < 0x02000000
	856	# ifndef PySequence_Size
	857	# define PySequence_Size PySequence_Length
	858	# endif
	859	#endif
	860
	861	/* PyBool_FromLong for old Pythons */
	862	#if PY_VERSION_HEX < 0x02030000
	863	static
	864	PyObject *PyBool_FromLong(long ok)
	865	{
	866	PyObject *result = ok ? Py_True : Py_False;
	867	Py_INCREF(result);
	868	return result;
	869	}
	870	#endif
	871
	872	/* Py_ssize_t for old Pythons */
	873	/* This code is as recommended by: */
	874	/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
	875	#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
	876	typedef int Py_ssize_t;
	877	# define PY_SSIZE_T_MAX INT_MAX
	878	# define PY_SSIZE_T_MIN INT_MIN
	879	typedef inquiry lenfunc;
	880	typedef intargfunc ssizeargfunc;
	881	typedef intintargfunc ssizessizeargfunc;
	882	typedef intobjargproc ssizeobjargproc;
	883	typedef intintobjargproc ssizessizeobjargproc;
	884	typedef getreadbufferproc readbufferproc;
	885	typedef getwritebufferproc writebufferproc;
	886	typedef getsegcountproc segcountproc;
	887	typedef getcharbufferproc charbufferproc;
	888	static long PyNumber_AsSsize_t (PyObject x, void SWIGUNUSEDPARM(exc))
	889	{
	890	long result = 0;
	891	PyObject *i = PyNumber_Int(x);
	892	if (i) {
	893	result = PyInt_AsLong(i);
	894	Py_DECREF(i);
	895	}
	896	return result;
	897	}
	898	#endif
	899
	900	#if PY_VERSION_HEX < 0x02050000
	901	#define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
	902	#endif
	903
	904	#if PY_VERSION_HEX < 0x02040000
	905	#define Py_VISIT(op) \
	906	do { \
	907	if (op) { \
	908	int vret = visit((op), arg); \
	909	if (vret) \
	910	return vret; \
	911	} \
	912	} while (0)
	913	#endif
	914
	915	#if PY_VERSION_HEX < 0x02030000
	916	typedef struct {
	917	PyTypeObject type;
	918	PyNumberMethods as_number;
	919	PyMappingMethods as_mapping;
	920	PySequenceMethods as_sequence;
	921	PyBufferProcs as_buffer;
	922	PyObject name, slots;
	923	} PyHeapTypeObject;
	924	#endif
	925
	926	#if PY_VERSION_HEX < 0x02030000
	927	typedef destructor freefunc;
	928	#endif
	929
	930	#if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) \|\| \
	931	(PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) \|\| \
	932	(PY_MAJOR_VERSION > 3))
	933	# define SWIGPY_USE_CAPSULE
	934	# define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
	935	#endif
	936
	937	#if PY_VERSION_HEX < 0x03020000
	938	#define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
	939	#define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
	940	#endif
	941
	942	/* -----------------------------------------------------------------------------
	943	* error manipulation
	944	* ----------------------------------------------------------------------------- */
	945
	946	SWIGRUNTIME PyObject*
	947	SWIG_Python_ErrorType(int code) {
	948	PyObject* type = 0;
	949	switch(code) {
	950	case SWIG_MemoryError:
	951	type = PyExc_MemoryError;
	952	break;
	953	case SWIG_IOError:
	954	type = PyExc_IOError;
	955	break;
	956	case SWIG_RuntimeError:
	957	type = PyExc_RuntimeError;
	958	break;
	959	case SWIG_IndexError:
	960	type = PyExc_IndexError;
	961	break;
	962	case SWIG_TypeError:
	963	type = PyExc_TypeError;
	964	break;
	965	case SWIG_DivisionByZero:
	966	type = PyExc_ZeroDivisionError;
	967	break;
	968	case SWIG_OverflowError:
	969	type = PyExc_OverflowError;
	970	break;
	971	case SWIG_SyntaxError:
	972	type = PyExc_SyntaxError;
	973	break;
	974	case SWIG_ValueError:
	975	type = PyExc_ValueError;
	976	break;
	977	case SWIG_SystemError:
	978	type = PyExc_SystemError;
	979	break;
	980	case SWIG_AttributeError:
	981	type = PyExc_AttributeError;
	982	break;
	983	default:
	984	type = PyExc_RuntimeError;
	985	}
	986	return type;
	987	}
	988
	989
	990	SWIGRUNTIME void
	991	SWIG_Python_AddErrorMsg(const char* mesg)
	992	{
	993	PyObject *type = 0;
	994	PyObject *value = 0;
	995	PyObject *traceback = 0;
	996
	997	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
	998	if (value) {
	999	char *tmp;
	1000	PyObject *old_str = PyObject_Str(value);
	1001	PyErr_Clear();
	1002	Py_XINCREF(type);
	1003
	1004	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
	1005	SWIG_Python_str_DelForPy3(tmp);
	1006	Py_DECREF(old_str);
	1007	Py_DECREF(value);
	1008	} else {
	1009	PyErr_SetString(PyExc_RuntimeError, mesg);
	1010	}
	1011	}
	1012
	1013	#if defined(SWIG_PYTHON_NO_THREADS)
	1014	# if defined(SWIG_PYTHON_THREADS)
	1015	# undef SWIG_PYTHON_THREADS
	1016	# endif
	1017	#endif
	1018	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
	1019	# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
	1020	# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
	1021	# define SWIG_PYTHON_USE_GIL
	1022	# endif
	1023	# endif
	1024	# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
	1025	# ifndef SWIG_PYTHON_INITIALIZE_THREADS
	1026	# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
	1027	# endif
	1028	# ifdef __cplusplus /* C++ code */
	1029	class SWIG_Python_Thread_Block {
	1030	bool status;
	1031	PyGILState_STATE state;
	1032	public:
	1033	void end() { if (status) { PyGILState_Release(state); status = false;} }
	1034	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
	1035	~SWIG_Python_Thread_Block() { end(); }
	1036	};
	1037	class SWIG_Python_Thread_Allow {
	1038	bool status;
	1039	PyThreadState *save;
	1040	public:
	1041	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
	1042	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
	1043	~SWIG_Python_Thread_Allow() { end(); }
	1044	};
	1045	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
	1046	# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
	1047	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
	1048	# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
	1049	# else /* C code */
	1050	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
	1051	# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
	1052	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
	1053	# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
	1054	# endif
	1055	# else /* Old thread way, not implemented, user must provide it */
	1056	# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
	1057	# define SWIG_PYTHON_INITIALIZE_THREADS
	1058	# endif
	1059	# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
	1060	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
	1061	# endif
	1062	# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
	1063	# define SWIG_PYTHON_THREAD_END_BLOCK
	1064	# endif
	1065	# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
	1066	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
	1067	# endif
	1068	# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
	1069	# define SWIG_PYTHON_THREAD_END_ALLOW
	1070	# endif
	1071	# endif
	1072	#else /* No thread support */
	1073	# define SWIG_PYTHON_INITIALIZE_THREADS
	1074	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
	1075	# define SWIG_PYTHON_THREAD_END_BLOCK
	1076	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
	1077	# define SWIG_PYTHON_THREAD_END_ALLOW
	1078	#endif
	1079
	1080	/* -----------------------------------------------------------------------------
	1081	* Python API portion that goes into the runtime
	1082	* ----------------------------------------------------------------------------- */
	1083
	1084	#ifdef __cplusplus
	1085	extern "C" {
	1086	#endif
	1087
	1088	/* -----------------------------------------------------------------------------
	1089	* Constant declarations
	1090	* ----------------------------------------------------------------------------- */
	1091
	1092	/* Constant Types */
	1093	#define SWIG_PY_POINTER 4
	1094	#define SWIG_PY_BINARY 5
	1095
	1096	/* Constant information structure */
	1097	typedef struct swig_const_info {
	1098	int type;
	1099	char *name;
	1100	long lvalue;
	1101	double dvalue;
	1102	void *pvalue;
	1103	swig_type_info **ptype;
	1104	} swig_const_info;
	1105
	1106
	1107	/* -----------------------------------------------------------------------------
	1108	* Wrapper of PyInstanceMethod_New() used in Python 3
	1109	* It is exported to the generated module, used for -fastproxy
	1110	* ----------------------------------------------------------------------------- */
	1111	#if PY_VERSION_HEX >= 0x03000000
	1112	SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject SWIGUNUSEDPARM(self), PyObject func)
	1113	{
	1114	return PyInstanceMethod_New(func);
	1115	}
	1116	#else
	1117	SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject SWIGUNUSEDPARM(self), PyObject SWIGUNUSEDPARM(func))
	1118	{
	1119	return NULL;
	1120	}
	1121	#endif
	1122
	1123	#ifdef __cplusplus
	1124	}
	1125	#endif
	1126
	1127
	1128	/* -----------------------------------------------------------------------------
	1129	* pyrun.swg
	1130	*
	1131	* This file contains the runtime support for Python modules
	1132	* and includes code for managing global variables and pointer
	1133	* type checking.
	1134	*
	1135	* ----------------------------------------------------------------------------- */
	1136
	1137	/* Common SWIG API */
	1138
	1139	/* for raw pointers */
	1140	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
	1141	#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
	1142	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
	1143
	1144	#ifdef SWIGPYTHON_BUILTIN
	1145	#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
	1146	#else
	1147	#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
	1148	#endif
	1149
	1150	#define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
	1151
	1152	#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
	1153	#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
	1154	#define swig_owntype int
	1155
	1156	/* for raw packed data */
	1157	#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
	1158	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
	1159
	1160	/* for class or struct pointers */
	1161	#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
	1162	#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
	1163
	1164	/* for C or C++ function pointers */
	1165	#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
	1166	#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
	1167
	1168	/* for C++ member pointers, ie, member methods */
	1169	#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
	1170	#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
	1171
	1172
	1173	/* Runtime API */
	1174
	1175	#define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
	1176	#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
	1177	#define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
	1178
	1179	#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
	1180	#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
	1181	#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
	1182	#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
	1183	#define SWIG_fail goto fail
	1184
	1185
	1186	/* Runtime API implementation */
	1187
	1188	/* Error manipulation */
	1189
	1190	SWIGINTERN void
	1191	SWIG_Python_SetErrorObj(PyObject errtype, PyObject obj) {
	1192	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	1193	PyErr_SetObject(errtype, obj);
	1194	Py_DECREF(obj);
	1195	SWIG_PYTHON_THREAD_END_BLOCK;
	1196	}
	1197
	1198	SWIGINTERN void
	1199	SWIG_Python_SetErrorMsg(PyObject errtype, const char msg) {
	1200	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
	1201	PyErr_SetString(errtype, msg);
	1202	SWIG_PYTHON_THREAD_END_BLOCK;
	1203	}
	1204
	1205	#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
	1206
	1207	/* Set a constant value */
	1208
	1209	#if defined(SWIGPYTHON_BUILTIN)
	1210
	1211	SWIGINTERN void
	1212	SwigPyBuiltin_AddPublicSymbol(PyObject seq, const char key) {
	1213	PyObject *s = PyString_InternFromString(key);
	1214	PyList_Append(seq, s);
	1215	Py_DECREF(s);
	1216	}
	1217
	1218	SWIGINTERN void
	1219	SWIG_Python_SetConstant(PyObject d, PyObject public_interface, const char name, PyObject obj) {
	1220	#if PY_VERSION_HEX < 0x02030000
	1221	PyDict_SetItemString(d, (char *)name, obj);
	1222	#else
	1223	PyDict_SetItemString(d, name, obj);
	1224	#endif
	1225	Py_DECREF(obj);
	1226	if (public_interface)
	1227	SwigPyBuiltin_AddPublicSymbol(public_interface, name);
	1228	}
	1229
	1230	#else
	1231
	1232	SWIGINTERN void
	1233	SWIG_Python_SetConstant(PyObject d, const char name, PyObject *obj) {
	1234	#if PY_VERSION_HEX < 0x02030000
	1235	PyDict_SetItemString(d, (char *)name, obj);
	1236	#else
	1237	PyDict_SetItemString(d, name, obj);
	1238	#endif
	1239	Py_DECREF(obj);
	1240	}
	1241
	1242	#endif
	1243
	1244	/* Append a value to the result obj */
	1245
	1246	SWIGINTERN PyObject*
	1247	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
	1248	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
	1249	if (!result) {
	1250	result = obj;
	1251	} else if (result == Py_None) {
	1252	Py_DECREF(result);
	1253	result = obj;
	1254	} else {
	1255	if (!PyList_Check(result)) {
	1256	PyObject *o2 = result;
	1257	result = PyList_New(1);
	1258	PyList_SetItem(result, 0, o2);
	1259	}
	1260	PyList_Append(result,obj);
	1261	Py_DECREF(obj);
	1262	}
	1263	return result;
	1264	#else
	1265	PyObject* o2;
	1266	PyObject* o3;
	1267	if (!result) {
	1268	result = obj;
	1269	} else if (result == Py_None) {
	1270	Py_DECREF(result);
	1271	result = obj;
	1272	} else {
	1273	if (!PyTuple_Check(result)) {
	1274	o2 = result;
	1275	result = PyTuple_New(1);
	1276	PyTuple_SET_ITEM(result, 0, o2);
	1277	}
	1278	o3 = PyTuple_New(1);
	1279	PyTuple_SET_ITEM(o3, 0, obj);
	1280	o2 = result;
	1281	result = PySequence_Concat(o2, o3);
	1282	Py_DECREF(o2);
	1283	Py_DECREF(o3);
	1284	}
	1285	return result;
	1286	#endif
	1287	}
	1288
	1289	/* Unpack the argument tuple */
	1290
	1291	SWIGINTERN int
	1292	SWIG_Python_UnpackTuple(PyObject args, const char name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
	1293	{
	1294	if (!args) {
	1295	if (!min && !max) {
	1296	return 1;
	1297	} else {
	1298	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
	1299	name, (min == max ? "" : "at least "), (int)min);
	1300	return 0;
	1301	}
	1302	}
	1303	if (!PyTuple_Check(args)) {
	1304	if (min <= 1 && max >= 1) {
	1305	int i;
	1306	objs[0] = args;
	1307	for (i = 1; i < max; ++i) {
	1308	objs[i] = 0;
	1309	}
	1310	return 2;
	1311	}
	1312	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
	1313	return 0;
	1314	} else {
	1315	Py_ssize_t l = PyTuple_GET_SIZE(args);
	1316	if (l < min) {
	1317	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
	1318	name, (min == max ? "" : "at least "), (int)min, (int)l);
	1319	return 0;
	1320	} else if (l > max) {
	1321	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
	1322	name, (min == max ? "" : "at most "), (int)max, (int)l);
	1323	return 0;
	1324	} else {
	1325	int i;
	1326	for (i = 0; i < l; ++i) {
	1327	objs[i] = PyTuple_GET_ITEM(args, i);
	1328	}
	1329	for (; l < max; ++l) {
	1330	objs[l] = 0;
	1331	}
	1332	return i + 1;
	1333	}
	1334	}
	1335	}
	1336
	1337	/* A functor is a function object with one single object argument */
	1338	#if PY_VERSION_HEX >= 0x02020000
	1339	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
	1340	#else
	1341	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
	1342	#endif
	1343
	1344	/*
	1345	Helper for static pointer initialization for both C and C++ code, for example
	1346	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
	1347	*/
	1348	#ifdef __cplusplus
	1349	#define SWIG_STATIC_POINTER(var) var
	1350	#else
	1351	#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
	1352	#endif
	1353
	1354	/* -----------------------------------------------------------------------------
	1355	* Pointer declarations
	1356	* ----------------------------------------------------------------------------- */
	1357
	1358	/* Flags for new pointer objects */
	1359	#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
	1360	#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW \| SWIG_POINTER_OWN)
	1361
	1362	#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
	1363
	1364	#define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
	1365	#define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT \| SWIG_POINTER_OWN)
	1366
	1367	#ifdef __cplusplus
	1368	extern "C" {
	1369	#endif
	1370
	1371	/* How to access Py_None */
	1372	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
	1373	# ifndef SWIG_PYTHON_NO_BUILD_NONE
	1374	# ifndef SWIG_PYTHON_BUILD_NONE
	1375	# define SWIG_PYTHON_BUILD_NONE
	1376	# endif
	1377	# endif
	1378	#endif
	1379
	1380	#ifdef SWIG_PYTHON_BUILD_NONE
	1381	# ifdef Py_None
	1382	# undef Py_None
	1383	# define Py_None SWIG_Py_None()
	1384	# endif
	1385	SWIGRUNTIMEINLINE PyObject *
	1386	_SWIG_Py_None(void)
	1387	{
	1388	PyObject none = Py_BuildValue((char)"");
	1389	Py_DECREF(none);
	1390	return none;
	1391	}
	1392	SWIGRUNTIME PyObject *
	1393	SWIG_Py_None(void)
	1394	{
	1395	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
	1396	return none;
	1397	}
	1398	#endif
	1399
	1400	/* The python void return value */
	1401
	1402	SWIGRUNTIMEINLINE PyObject *
	1403	SWIG_Py_Void(void)
	1404	{
	1405	PyObject *none = Py_None;
	1406	Py_INCREF(none);
	1407	return none;
	1408	}
	1409
	1410	/* SwigPyClientData */
	1411
	1412	typedef struct {
	1413	PyObject *klass;
	1414	PyObject *newraw;
	1415	PyObject *newargs;
	1416	PyObject *destroy;
	1417	int delargs;
	1418	int implicitconv;
	1419	PyTypeObject *pytype;
	1420	} SwigPyClientData;
	1421
	1422	SWIGRUNTIMEINLINE int
	1423	SWIG_Python_CheckImplicit(swig_type_info *ty)
	1424	{
	1425	SwigPyClientData data = (SwigPyClientData )ty->clientdata;
	1426	return data ? data->implicitconv : 0;
	1427	}
	1428
	1429	SWIGRUNTIMEINLINE PyObject *
	1430	SWIG_Python_ExceptionType(swig_type_info *desc) {
	1431	SwigPyClientData data = desc ? (SwigPyClientData ) desc->clientdata : 0;
	1432	PyObject *klass = data ? data->klass : 0;
	1433	return (klass ? klass : PyExc_RuntimeError);
	1434	}
	1435
	1436
	1437	SWIGRUNTIME SwigPyClientData *
	1438	SwigPyClientData_New(PyObject* obj)
	1439	{
	1440	if (!obj) {
	1441	return 0;
	1442	} else {
	1443	SwigPyClientData data = (SwigPyClientData )malloc(sizeof(SwigPyClientData));
	1444	/* the klass element */
	1445	data->klass = obj;
	1446	Py_INCREF(data->klass);
	1447	/* the newraw method and newargs arguments used to create a new raw instance */
	1448	if (PyClass_Check(obj)) {
	1449	data->newraw = 0;
	1450	data->newargs = obj;
	1451	Py_INCREF(obj);
	1452	} else {
	1453	#if (PY_VERSION_HEX < 0x02020000)
	1454	data->newraw = 0;
	1455	#else
	1456	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
	1457	#endif
	1458	if (data->newraw) {
	1459	Py_INCREF(data->newraw);
	1460	data->newargs = PyTuple_New(1);
	1461	PyTuple_SetItem(data->newargs, 0, obj);
	1462	} else {
	1463	data->newargs = obj;
	1464	}
	1465	Py_INCREF(data->newargs);
	1466	}
	1467	/* the destroy method, aka as the C++ delete method */
	1468	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
	1469	if (PyErr_Occurred()) {
	1470	PyErr_Clear();
	1471	data->destroy = 0;
	1472	}
	1473	if (data->destroy) {
	1474	int flags;
	1475	Py_INCREF(data->destroy);
	1476	flags = PyCFunction_GET_FLAGS(data->destroy);
	1477	#ifdef METH_O
	1478	data->delargs = !(flags & (METH_O));
	1479	#else
	1480	data->delargs = 0;
	1481	#endif
	1482	} else {
	1483	data->delargs = 0;
	1484	}
	1485	data->implicitconv = 0;
	1486	data->pytype = 0;
	1487	return data;
	1488	}
	1489	}
	1490
	1491	SWIGRUNTIME void
	1492	SwigPyClientData_Del(SwigPyClientData *data) {
	1493	Py_XDECREF(data->newraw);
	1494	Py_XDECREF(data->newargs);
	1495	Py_XDECREF(data->destroy);
	1496	}
	1497
	1498	/* =============== SwigPyObject =====================*/
	1499
	1500	typedef struct {
	1501	PyObject_HEAD
	1502	void *ptr;
	1503	swig_type_info *ty;
	1504	int own;
	1505	PyObject *next;
	1506	#ifdef SWIGPYTHON_BUILTIN
	1507	PyObject *dict;
	1508	#endif
	1509	} SwigPyObject;
	1510
	1511	SWIGRUNTIME PyObject *
	1512	SwigPyObject_long(SwigPyObject *v)
	1513	{
	1514	return PyLong_FromVoidPtr(v->ptr);
	1515	}
	1516
	1517	SWIGRUNTIME PyObject *
	1518	SwigPyObject_format(const char* fmt, SwigPyObject *v)
	1519	{
	1520	PyObject *res = NULL;
	1521	PyObject *args = PyTuple_New(1);
	1522	if (args) {
	1523	if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
	1524	PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
	1525	if (ofmt) {
	1526	#if PY_VERSION_HEX >= 0x03000000
	1527	res = PyUnicode_Format(ofmt,args);
	1528	#else
	1529	res = PyString_Format(ofmt,args);
	1530	#endif
	1531	Py_DECREF(ofmt);
	1532	}
	1533	Py_DECREF(args);
	1534	}
	1535	}
	1536	return res;
	1537	}
	1538
	1539	SWIGRUNTIME PyObject *
	1540	SwigPyObject_oct(SwigPyObject *v)
	1541	{
	1542	return SwigPyObject_format("%o",v);
	1543	}
	1544
	1545	SWIGRUNTIME PyObject *
	1546	SwigPyObject_hex(SwigPyObject *v)
	1547	{
	1548	return SwigPyObject_format("%x",v);
	1549	}
	1550
	1551	SWIGRUNTIME PyObject *
	1552	#ifdef METH_NOARGS
	1553	SwigPyObject_repr(SwigPyObject *v)
	1554	#else
	1555	SwigPyObject_repr(SwigPyObject v, PyObject args)
	1556	#endif
	1557	{
	1558	const char *name = SWIG_TypePrettyName(v->ty);
	1559	PyObject repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void )v);
	1560	if (v->next) {
	1561	# ifdef METH_NOARGS
	1562	PyObject nrep = SwigPyObject_repr((SwigPyObject )v->next);
	1563	# else
	1564	PyObject nrep = SwigPyObject_repr((SwigPyObject )v->next, args);
	1565	# endif
	1566	# if PY_VERSION_HEX >= 0x03000000
	1567	PyObject *joined = PyUnicode_Concat(repr, nrep);
	1568	Py_DecRef(repr);
	1569	Py_DecRef(nrep);
	1570	repr = joined;
	1571	# else
	1572	PyString_ConcatAndDel(&repr,nrep);
	1573	# endif
	1574	}
	1575	return repr;
	1576	}
	1577
	1578	SWIGRUNTIME int
	1579	SwigPyObject_compare(SwigPyObject v, SwigPyObject w)
	1580	{
	1581	void *i = v->ptr;
	1582	void *j = w->ptr;
	1583	return (i < j) ? -1 : ((i > j) ? 1 : 0);
	1584	}
	1585
	1586	/* Added for Python 3.x, would it also be useful for Python 2.x? */
	1587	SWIGRUNTIME PyObject*
	1588	SwigPyObject_richcompare(SwigPyObject v, SwigPyObject w, int op)
	1589	{
	1590	PyObject* res;
	1591	if( op != Py_EQ && op != Py_NE ) {
	1592	Py_INCREF(Py_NotImplemented);
	1593	return Py_NotImplemented;
	1594	}
	1595	res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
	1596	return res;
	1597	}
	1598
	1599
	1600	SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
	1601
	1602	#ifdef SWIGPYTHON_BUILTIN
	1603	static swig_type_info *SwigPyObject_stype = 0;
	1604	SWIGRUNTIME PyTypeObject*
	1605	SwigPyObject_type(void) {
	1606	SwigPyClientData *cd;
	1607	assert(SwigPyObject_stype);
	1608	cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
	1609	assert(cd);
	1610	assert(cd->pytype);
	1611	return cd->pytype;
	1612	}
	1613	#else
	1614	SWIGRUNTIME PyTypeObject*
	1615	SwigPyObject_type(void) {
	1616	static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
	1617	return type;
	1618	}
	1619	#endif
	1620
	1621	SWIGRUNTIMEINLINE int
	1622	SwigPyObject_Check(PyObject *op) {
	1623	#ifdef SWIGPYTHON_BUILTIN
	1624	PyTypeObject *target_tp = SwigPyObject_type();
	1625	if (PyType_IsSubtype(op->ob_type, target_tp))
	1626	return 1;
	1627	return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
	1628	#else
	1629	return (Py_TYPE(op) == SwigPyObject_type())
	1630	\|\| (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
	1631	#endif
	1632	}
	1633
	1634	SWIGRUNTIME PyObject *
	1635	SwigPyObject_New(void ptr, swig_type_info ty, int own);
	1636
	1637	SWIGRUNTIME void
	1638	SwigPyObject_dealloc(PyObject *v)
	1639	{
	1640	SwigPyObject sobj = (SwigPyObject ) v;
	1641	PyObject *next = sobj->next;
	1642	if (sobj->own == SWIG_POINTER_OWN) {
	1643	swig_type_info *ty = sobj->ty;
	1644	SwigPyClientData data = ty ? (SwigPyClientData ) ty->clientdata : 0;
	1645	PyObject *destroy = data ? data->destroy : 0;
	1646	if (destroy) {
	1647	/* destroy is always a VARARGS method */
	1648	PyObject *res;
	1649	if (data->delargs) {
	1650	/* we need to create a temporary object to carry the destroy operation */
	1651	PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
	1652	res = SWIG_Python_CallFunctor(destroy, tmp);
	1653	Py_DECREF(tmp);
	1654	} else {
	1655	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
	1656	PyObject *mself = PyCFunction_GET_SELF(destroy);
	1657	res = ((*meth)(mself, v));
	1658	}
	1659	Py_XDECREF(res);
	1660	}
	1661	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
	1662	else {
	1663	const char *name = SWIG_TypePrettyName(ty);
	1664	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
	1665	}
	1666	#endif
	1667	}
	1668	Py_XDECREF(next);
	1669	PyObject_DEL(v);
	1670	}
	1671
	1672	SWIGRUNTIME PyObject*
	1673	SwigPyObject_append(PyObject* v, PyObject* next)
	1674	{
	1675	SwigPyObject sobj = (SwigPyObject ) v;
	1676	#ifndef METH_O
	1677	PyObject *tmp = 0;
	1678	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
	1679	next = tmp;
	1680	#endif
	1681	if (!SwigPyObject_Check(next)) {
	1682	return NULL;
	1683	}
	1684	sobj->next = next;
	1685	Py_INCREF(next);
	1686	return SWIG_Py_Void();
	1687	}
	1688
	1689	SWIGRUNTIME PyObject*
	1690	#ifdef METH_NOARGS
	1691	SwigPyObject_next(PyObject* v)
	1692	#else
	1693	SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
	1694	#endif
	1695	{
	1696	SwigPyObject sobj = (SwigPyObject ) v;
	1697	if (sobj->next) {
	1698	Py_INCREF(sobj->next);
	1699	return sobj->next;
	1700	} else {
	1701	return SWIG_Py_Void();
	1702	}
	1703	}
	1704
	1705	SWIGINTERN PyObject*
	1706	#ifdef METH_NOARGS
	1707	SwigPyObject_disown(PyObject *v)
	1708	#else
	1709	SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
	1710	#endif
	1711	{
	1712	SwigPyObject sobj = (SwigPyObject )v;
	1713	sobj->own = 0;
	1714	return SWIG_Py_Void();
	1715	}
	1716
	1717	SWIGINTERN PyObject*
	1718	#ifdef METH_NOARGS
	1719	SwigPyObject_acquire(PyObject *v)
	1720	#else
	1721	SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
	1722	#endif
	1723	{
	1724	SwigPyObject sobj = (SwigPyObject )v;
	1725	sobj->own = SWIG_POINTER_OWN;
	1726	return SWIG_Py_Void();
	1727	}
	1728
	1729	SWIGINTERN PyObject*
	1730	SwigPyObject_own(PyObject v, PyObject args)
	1731	{
	1732	PyObject *val = 0;
	1733	#if (PY_VERSION_HEX < 0x02020000)
	1734	if (!PyArg_ParseTuple(args,(char *)"\|O:own",&val))
	1735	#elif (PY_VERSION_HEX < 0x02050000)
	1736	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
	1737	#else
	1738	if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
	1739	#endif
	1740	{
	1741	return NULL;
	1742	}
	1743	else
	1744	{
	1745	SwigPyObject sobj = (SwigPyObject )v;
	1746	PyObject *obj = PyBool_FromLong(sobj->own);
	1747	if (val) {
	1748	#ifdef METH_NOARGS
	1749	if (PyObject_IsTrue(val)) {
	1750	SwigPyObject_acquire(v);
	1751	} else {
	1752	SwigPyObject_disown(v);
	1753	}
	1754	#else
	1755	if (PyObject_IsTrue(val)) {
	1756	SwigPyObject_acquire(v,args);
	1757	} else {
	1758	SwigPyObject_disown(v,args);
	1759	}
	1760	#endif
	1761	}
	1762	return obj;
	1763	}
	1764	}
	1765
	1766	#ifdef METH_O
	1767	static PyMethodDef
	1768	swigobject_methods[] = {
	1769	{(char )"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char )"releases ownership of the pointer"},
	1770	{(char )"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char )"acquires ownership of the pointer"},
	1771	{(char )"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
	1772	{(char )"append", (PyCFunction)SwigPyObject_append, METH_O, (char )"appends another 'this' object"},
	1773	{(char )"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char )"returns the next 'this' object"},
	1774	{(char )"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char )"returns object representation"},
	1775	{0, 0, 0, 0}
	1776	};
	1777	#else
	1778	static PyMethodDef
	1779	swigobject_methods[] = {
	1780	{(char )"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char )"releases ownership of the pointer"},
	1781	{(char )"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char )"aquires ownership of the pointer"},
	1782	{(char )"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
	1783	{(char )"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char )"appends another 'this' object"},
	1784	{(char )"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char )"returns the next 'this' object"},
	1785	{(char )"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char )"returns object representation"},
	1786	{0, 0, 0, 0}
	1787	};
	1788	#endif
	1789
	1790	#if PY_VERSION_HEX < 0x02020000
	1791	SWIGINTERN PyObject *
	1792	SwigPyObject_getattr(SwigPyObject sobj,char name)
	1793	{
	1794	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
	1795	}
	1796	#endif
	1797
	1798	SWIGRUNTIME PyTypeObject*
	1799	SwigPyObject_TypeOnce(void) {
	1800	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
	1801
	1802	static PyNumberMethods SwigPyObject_as_number = {
	1803	(binaryfunc)0, /nb_add/
	1804	(binaryfunc)0, /nb_subtract/
	1805	(binaryfunc)0, /nb_multiply/
	1806	/* nb_divide removed in Python 3 */
	1807	#if PY_VERSION_HEX < 0x03000000
	1808	(binaryfunc)0, /nb_divide/
	1809	#endif
	1810	(binaryfunc)0, /nb_remainder/
	1811	(binaryfunc)0, /nb_divmod/
	1812	(ternaryfunc)0,/nb_power/
	1813	(unaryfunc)0, /nb_negative/
	1814	(unaryfunc)0, /nb_positive/
	1815	(unaryfunc)0, /nb_absolute/
	1816	(inquiry)0, /nb_nonzero/
	1817	0, /nb_invert/
	1818	0, /nb_lshift/
	1819	0, /nb_rshift/
	1820	0, /nb_and/
	1821	0, /nb_xor/
	1822	0, /nb_or/
	1823	#if PY_VERSION_HEX < 0x03000000
	1824	0, /nb_coerce/
	1825	#endif
	1826	(unaryfunc)SwigPyObject_long, /nb_int/
	1827	#if PY_VERSION_HEX < 0x03000000
	1828	(unaryfunc)SwigPyObject_long, /nb_long/
	1829	#else
	1830	0, /nb_reserved/
	1831	#endif
	1832	(unaryfunc)0, /nb_float/
	1833	#if PY_VERSION_HEX < 0x03000000
	1834	(unaryfunc)SwigPyObject_oct, /nb_oct/
	1835	(unaryfunc)SwigPyObject_hex, /nb_hex/
	1836	#endif
	1837	#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
	1838	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
	1839	#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
	1840	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
	1841	#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
	1842	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
	1843	#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
	1844	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
	1845	#endif
	1846	};
	1847
	1848	static PyTypeObject swigpyobject_type;
	1849	static int type_init = 0;
	1850	if (!type_init) {
	1851	const PyTypeObject tmp = {
	1852	/* PyObject header changed in Python 3 */
	1853	#if PY_VERSION_HEX >= 0x03000000
	1854	PyVarObject_HEAD_INIT(NULL, 0)
	1855	#else
	1856	PyObject_HEAD_INIT(NULL)
	1857	0, /* ob_size */
	1858	#endif
	1859	(char )"SwigPyObject", / tp_name */
	1860	sizeof(SwigPyObject), /* tp_basicsize */
	1861	0, /* tp_itemsize */
	1862	(destructor)SwigPyObject_dealloc, /* tp_dealloc */
	1863	0, /* tp_print */
	1864	#if PY_VERSION_HEX < 0x02020000
	1865	(getattrfunc)SwigPyObject_getattr, /* tp_getattr */
	1866	#else
	1867	(getattrfunc)0, /* tp_getattr */
	1868	#endif
	1869	(setattrfunc)0, /* tp_setattr */
	1870	#if PY_VERSION_HEX >= 0x03000000
	1871	0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
	1872	#else
	1873	(cmpfunc)SwigPyObject_compare, /* tp_compare */
	1874	#endif
	1875	(reprfunc)SwigPyObject_repr, /* tp_repr */
	1876	&SwigPyObject_as_number, /* tp_as_number */
	1877	0, /* tp_as_sequence */
	1878	0, /* tp_as_mapping */
	1879	(hashfunc)0, /* tp_hash */
	1880	(ternaryfunc)0, /* tp_call */
	1881	0, /* tp_str */
	1882	PyObject_GenericGetAttr, /* tp_getattro */
	1883	0, /* tp_setattro */
	1884	0, /* tp_as_buffer */
	1885	Py_TPFLAGS_DEFAULT, /* tp_flags */
	1886	swigobject_doc, /* tp_doc */
	1887	0, /* tp_traverse */
	1888	0, /* tp_clear */
	1889	(richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
	1890	0, /* tp_weaklistoffset */
	1891	#if PY_VERSION_HEX >= 0x02020000
	1892	0, /* tp_iter */
	1893	0, /* tp_iternext */
	1894	swigobject_methods, /* tp_methods */
	1895	0, /* tp_members */
	1896	0, /* tp_getset */
	1897	0, /* tp_base */
	1898	0, /* tp_dict */
	1899	0, /* tp_descr_get */
	1900	0, /* tp_descr_set */
	1901	0, /* tp_dictoffset */
	1902	0, /* tp_init */
	1903	0, /* tp_alloc */
	1904	0, /* tp_new */
	1905	0, /* tp_free */
	1906	0, /* tp_is_gc */
	1907	0, /* tp_bases */
	1908	0, /* tp_mro */
	1909	0, /* tp_cache */
	1910	0, /* tp_subclasses */
	1911	0, /* tp_weaklist */
	1912	#endif
	1913	#if PY_VERSION_HEX >= 0x02030000
	1914	0, /* tp_del */
	1915	#endif
	1916	#if PY_VERSION_HEX >= 0x02060000
	1917	0, /* tp_version */
	1918	#endif
	1919	#ifdef COUNT_ALLOCS
	1920	0,0,0,0 /* tp_alloc -> tp_next */
	1921	#endif
	1922	};
	1923	swigpyobject_type = tmp;
	1924	type_init = 1;
	1925	#if PY_VERSION_HEX < 0x02020000
	1926	swigpyobject_type.ob_type = &PyType_Type;
	1927	#else
	1928	if (PyType_Ready(&swigpyobject_type) < 0)
	1929	return NULL;
	1930	#endif
	1931	}
	1932	return &swigpyobject_type;
	1933	}
	1934
	1935	SWIGRUNTIME PyObject *
	1936	SwigPyObject_New(void ptr, swig_type_info ty, int own)
	1937	{
	1938	SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
	1939	if (sobj) {
	1940	sobj->ptr = ptr;
	1941	sobj->ty = ty;
	1942	sobj->own = own;
	1943	sobj->next = 0;
	1944	}
	1945	return (PyObject *)sobj;
	1946	}
	1947
	1948	/* -----------------------------------------------------------------------------
	1949	* Implements a simple Swig Packed type, and use it instead of string
	1950	* ----------------------------------------------------------------------------- */
	1951
	1952	typedef struct {
	1953	PyObject_HEAD
	1954	void *pack;
	1955	swig_type_info *ty;
	1956	size_t size;
	1957	} SwigPyPacked;
	1958
	1959	SWIGRUNTIME int
	1960	SwigPyPacked_print(SwigPyPacked v, FILE fp, int SWIGUNUSEDPARM(flags))
	1961	{
	1962	char result[SWIG_BUFFER_SIZE];
	1963	fputs("<Swig Packed ", fp);
	1964	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
	1965	fputs("at ", fp);
	1966	fputs(result, fp);
	1967	}
	1968	fputs(v->ty->name,fp);
	1969	fputs(">", fp);
	1970	return 0;
	1971	}
	1972
	1973	SWIGRUNTIME PyObject *
	1974	SwigPyPacked_repr(SwigPyPacked *v)
	1975	{
	1976	char result[SWIG_BUFFER_SIZE];
	1977	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
	1978	return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
	1979	} else {
	1980	return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
	1981	}
	1982	}
	1983
	1984	SWIGRUNTIME PyObject *
	1985	SwigPyPacked_str(SwigPyPacked *v)
	1986	{
	1987	char result[SWIG_BUFFER_SIZE];
	1988	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
	1989	return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
	1990	} else {
	1991	return SWIG_Python_str_FromChar(v->ty->name);
	1992	}
	1993	}
	1994
	1995	SWIGRUNTIME int
	1996	SwigPyPacked_compare(SwigPyPacked v, SwigPyPacked w)
	1997	{
	1998	size_t i = v->size;
	1999	size_t j = w->size;
	2000	int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
	2001	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
	2002	}
	2003
	2004	SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
	2005
	2006	SWIGRUNTIME PyTypeObject*
	2007	SwigPyPacked_type(void) {
	2008	static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
	2009	return type;
	2010	}
	2011
	2012	SWIGRUNTIMEINLINE int
	2013	SwigPyPacked_Check(PyObject *op) {
	2014	return ((op)->ob_type == SwigPyPacked_TypeOnce())
	2015	\|\| (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
	2016	}
	2017
	2018	SWIGRUNTIME void
	2019	SwigPyPacked_dealloc(PyObject *v)
	2020	{
	2021	if (SwigPyPacked_Check(v)) {
	2022	SwigPyPacked sobj = (SwigPyPacked ) v;
	2023	free(sobj->pack);
	2024	}
	2025	PyObject_DEL(v);
	2026	}
	2027
	2028	SWIGRUNTIME PyTypeObject*
	2029	SwigPyPacked_TypeOnce(void) {
	2030	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
	2031	static PyTypeObject swigpypacked_type;
	2032	static int type_init = 0;
	2033	if (!type_init) {
	2034	const PyTypeObject tmp = {
	2035	/* PyObject header changed in Python 3 */
	2036	#if PY_VERSION_HEX>=0x03000000
	2037	PyVarObject_HEAD_INIT(NULL, 0)
	2038	#else
	2039	PyObject_HEAD_INIT(NULL)
	2040	0, /* ob_size */
	2041	#endif
	2042	(char )"SwigPyPacked", / tp_name */
	2043	sizeof(SwigPyPacked), /* tp_basicsize */
	2044	0, /* tp_itemsize */
	2045	(destructor)SwigPyPacked_dealloc, /* tp_dealloc */
	2046	(printfunc)SwigPyPacked_print, /* tp_print */
	2047	(getattrfunc)0, /* tp_getattr */
	2048	(setattrfunc)0, /* tp_setattr */
	2049	#if PY_VERSION_HEX>=0x03000000
	2050	0, /* tp_reserved in 3.0.1 */
	2051	#else
	2052	(cmpfunc)SwigPyPacked_compare, /* tp_compare */
	2053	#endif
	2054	(reprfunc)SwigPyPacked_repr, /* tp_repr */
	2055	0, /* tp_as_number */
	2056	0, /* tp_as_sequence */
	2057	0, /* tp_as_mapping */
	2058	(hashfunc)0, /* tp_hash */
	2059	(ternaryfunc)0, /* tp_call */
	2060	(reprfunc)SwigPyPacked_str, /* tp_str */
	2061	PyObject_GenericGetAttr, /* tp_getattro */
	2062	0, /* tp_setattro */
	2063	0, /* tp_as_buffer */
	2064	Py_TPFLAGS_DEFAULT, /* tp_flags */
	2065	swigpacked_doc, /* tp_doc */
	2066	0, /* tp_traverse */
	2067	0, /* tp_clear */
	2068	0, /* tp_richcompare */
	2069	0, /* tp_weaklistoffset */
	2070	#if PY_VERSION_HEX >= 0x02020000
	2071	0, /* tp_iter */
	2072	0, /* tp_iternext */
	2073	0, /* tp_methods */
	2074	0, /* tp_members */
	2075	0, /* tp_getset */
	2076	0, /* tp_base */
	2077	0, /* tp_dict */
	2078	0, /* tp_descr_get */
	2079	0, /* tp_descr_set */
	2080	0, /* tp_dictoffset */
	2081	0, /* tp_init */
	2082	0, /* tp_alloc */
	2083	0, /* tp_new */
	2084	0, /* tp_free */
	2085	0, /* tp_is_gc */
	2086	0, /* tp_bases */
	2087	0, /* tp_mro */
	2088	0, /* tp_cache */
	2089	0, /* tp_subclasses */
	2090	0, /* tp_weaklist */
	2091	#endif
	2092	#if PY_VERSION_HEX >= 0x02030000
	2093	0, /* tp_del */
	2094	#endif
	2095	#if PY_VERSION_HEX >= 0x02060000
	2096	0, /* tp_version */
	2097	#endif
	2098	#ifdef COUNT_ALLOCS
	2099	0,0,0,0 /* tp_alloc -> tp_next */
	2100	#endif
	2101	};
	2102	swigpypacked_type = tmp;
	2103	type_init = 1;
	2104	#if PY_VERSION_HEX < 0x02020000
	2105	swigpypacked_type.ob_type = &PyType_Type;
	2106	#else
	2107	if (PyType_Ready(&swigpypacked_type) < 0)
	2108	return NULL;
	2109	#endif
	2110	}
	2111	return &swigpypacked_type;
	2112	}
	2113
	2114	SWIGRUNTIME PyObject *
	2115	SwigPyPacked_New(void ptr, size_t size, swig_type_info ty)
	2116	{
	2117	SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
	2118	if (sobj) {
	2119	void *pack = malloc(size);
	2120	if (pack) {
	2121	memcpy(pack, ptr, size);
	2122	sobj->pack = pack;
	2123	sobj->ty = ty;
	2124	sobj->size = size;
	2125	} else {
	2126	PyObject_DEL((PyObject *) sobj);
	2127	sobj = 0;
	2128	}
	2129	}
	2130	return (PyObject *) sobj;
	2131	}
	2132
	2133	SWIGRUNTIME swig_type_info *
	2134	SwigPyPacked_UnpackData(PyObject obj, void ptr, size_t size)
	2135	{
	2136	if (SwigPyPacked_Check(obj)) {
	2137	SwigPyPacked sobj = (SwigPyPacked )obj;
	2138	if (sobj->size != size) return 0;
	2139	memcpy(ptr, sobj->pack, size);
	2140	return sobj->ty;
	2141	} else {
	2142	return 0;
	2143	}
	2144	}
	2145
	2146	/* -----------------------------------------------------------------------------
	2147	* pointers/data manipulation
	2148	* ----------------------------------------------------------------------------- */
	2149
	2150	SWIGRUNTIMEINLINE PyObject *
	2151	_SWIG_This(void)
	2152	{
	2153	return SWIG_Python_str_FromChar("this");
	2154	}
	2155
	2156	static PyObject *swig_this = NULL;
	2157
	2158	SWIGRUNTIME PyObject *
	2159	SWIG_This(void)
	2160	{
	2161	if (swig_this == NULL)
	2162	swig_this = _SWIG_This();
	2163	return swig_this;
	2164	}
	2165
	2166	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
	2167
	2168	/* TODO: I don't know how to implement the fast getset in Python 3 right now */
	2169	#if PY_VERSION_HEX>=0x03000000
	2170	#define SWIG_PYTHON_SLOW_GETSET_THIS
	2171	#endif
	2172
	2173	SWIGRUNTIME SwigPyObject *
	2174	SWIG_Python_GetSwigThis(PyObject *pyobj)
	2175	{
	2176	PyObject *obj;
	2177
	2178	if (SwigPyObject_Check(pyobj))
	2179	return (SwigPyObject *) pyobj;
	2180
	2181	#ifdef SWIGPYTHON_BUILTIN
	2182	(void)obj;
	2183	# ifdef PyWeakref_CheckProxy
	2184	if (PyWeakref_CheckProxy(pyobj)) {
	2185	pyobj = PyWeakref_GET_OBJECT(pyobj);
	2186	if (pyobj && SwigPyObject_Check(pyobj))
	2187	return (SwigPyObject*) pyobj;
	2188	}
	2189	# endif
	2190	return NULL;
	2191	#else
	2192
	2193	obj = 0;
	2194
	2195	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
	2196	if (PyInstance_Check(pyobj)) {
	2197	obj = _PyInstance_Lookup(pyobj, SWIG_This());
	2198	} else {
	2199	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
	2200	if (dictptr != NULL) {
	2201	PyObject dict = dictptr;
	2202	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
	2203	} else {
	2204	#ifdef PyWeakref_CheckProxy
	2205	if (PyWeakref_CheckProxy(pyobj)) {
	2206	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
	2207	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
	2208	}
	2209	#endif
	2210	obj = PyObject_GetAttr(pyobj,SWIG_This());
	2211	if (obj) {
	2212	Py_DECREF(obj);
	2213	} else {
	2214	if (PyErr_Occurred()) PyErr_Clear();
	2215	return 0;
	2216	}
	2217	}
	2218	}
	2219	#else
	2220	obj = PyObject_GetAttr(pyobj,SWIG_This());
	2221	if (obj) {
	2222	Py_DECREF(obj);
	2223	} else {
	2224	if (PyErr_Occurred()) PyErr_Clear();
	2225	return 0;
	2226	}
	2227	#endif
	2228	if (obj && !SwigPyObject_Check(obj)) {
	2229	/* a PyObject is called 'this', try to get the 'real this'
	2230	SwigPyObject from it */
	2231	return SWIG_Python_GetSwigThis(obj);
	2232	}
	2233	return (SwigPyObject *)obj;
	2234	#endif
	2235	}
	2236
	2237	/* Acquire a pointer value */
	2238
	2239	SWIGRUNTIME int
	2240	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
	2241	if (own == SWIG_POINTER_OWN) {
	2242	SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
	2243	if (sobj) {
	2244	int oldown = sobj->own;
	2245	sobj->own = own;
	2246	return oldown;
	2247	}
	2248	}
	2249	return 0;
	2250	}
	2251
	2252	/* Convert a pointer value */
	2253
	2254	SWIGRUNTIME int
	2255	SWIG_Python_ConvertPtrAndOwn(PyObject obj, void ptr, swig_type_info ty, int flags, int *own) {
	2256	int res;
	2257	SwigPyObject *sobj;
	2258	int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
	2259
	2260	if (!obj)
	2261	return SWIG_ERROR;
	2262	if (obj == Py_None && !implicit_conv) {
	2263	if (ptr)
	2264	*ptr = 0;
	2265	return SWIG_OK;
	2266	}
	2267
	2268	res = SWIG_ERROR;
	2269
	2270	sobj = SWIG_Python_GetSwigThis(obj);
	2271	if (own)
	2272	*own = 0;
	2273	while (sobj) {
	2274	void *vptr = sobj->ptr;
	2275	if (ty) {
	2276	swig_type_info *to = sobj->ty;
	2277	if (to == ty) {
	2278	/* no type cast needed */
	2279	if (ptr) *ptr = vptr;
	2280	break;
	2281	} else {
	2282	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
	2283	if (!tc) {
	2284	sobj = (SwigPyObject *)sobj->next;
	2285	} else {
	2286	if (ptr) {
	2287	int newmemory = 0;
	2288	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
	2289	if (newmemory == SWIG_CAST_NEW_MEMORY) {
	2290	assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete ptr /
	2291	if (own)
	2292	own = own \| SWIG_CAST_NEW_MEMORY;
	2293	}
	2294	}
	2295	break;
	2296	}
	2297	}
	2298	} else {
	2299	if (ptr) *ptr = vptr;
	2300	break;
	2301	}
	2302	}
	2303	if (sobj) {
	2304	if (own)
	2305	own = own \| sobj->own;
	2306	if (flags & SWIG_POINTER_DISOWN) {
	2307	sobj->own = 0;
	2308	}
	2309	res = SWIG_OK;
	2310	} else {
	2311	if (implicit_conv) {
	2312	SwigPyClientData data = ty ? (SwigPyClientData ) ty->clientdata : 0;
	2313	if (data && !data->implicitconv) {
	2314	PyObject *klass = data->klass;
	2315	if (klass) {
	2316	PyObject *impconv;
	2317	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
	2318	impconv = SWIG_Python_CallFunctor(klass, obj);
	2319	data->implicitconv = 0;
	2320	if (PyErr_Occurred()) {
	2321	PyErr_Clear();
	2322	impconv = 0;
	2323	}
	2324	if (impconv) {
	2325	SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
	2326	if (iobj) {
	2327	void *vptr;
	2328	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
	2329	if (SWIG_IsOK(res)) {
	2330	if (ptr) {
	2331	*ptr = vptr;
	2332	/* transfer the ownership to 'ptr' */
	2333	iobj->own = 0;
	2334	res = SWIG_AddCast(res);
	2335	res = SWIG_AddNewMask(res);
	2336	} else {
	2337	res = SWIG_AddCast(res);
	2338	}
	2339	}
	2340	}
	2341	Py_DECREF(impconv);
	2342	}
	2343	}
	2344	}
	2345	}
	2346	if (!SWIG_IsOK(res) && obj == Py_None) {
	2347	if (ptr)
	2348	*ptr = 0;
	2349	if (PyErr_Occurred())
	2350	PyErr_Clear();
	2351	res = SWIG_OK;
	2352	}
	2353	}
	2354	return res;
	2355	}
	2356
	2357	/* Convert a function ptr value */
	2358
	2359	SWIGRUNTIME int
	2360	SWIG_Python_ConvertFunctionPtr(PyObject obj, void ptr, swig_type_info ty) {
	2361	if (!PyCFunction_Check(obj)) {
	2362	return SWIG_ConvertPtr(obj, ptr, ty, 0);
	2363	} else {
	2364	void *vptr = 0;
	2365
	2366	/* here we get the method pointer for callbacks */
	2367	const char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
	2368	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
	2369	if (desc)
	2370	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
	2371	if (!desc)
	2372	return SWIG_ERROR;
	2373	if (ty) {
	2374	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
	2375	if (tc) {
	2376	int newmemory = 0;
	2377	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
	2378	assert(!newmemory); /* newmemory handling not yet implemented */
	2379	} else {
	2380	return SWIG_ERROR;
	2381	}
	2382	} else {
	2383	*ptr = vptr;
	2384	}
	2385	return SWIG_OK;
	2386	}
	2387	}
	2388
	2389	/* Convert a packed value value */
	2390
	2391	SWIGRUNTIME int
	2392	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty) {
	2393	swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
	2394	if (!to) return SWIG_ERROR;
	2395	if (ty) {
	2396	if (to != ty) {
	2397	/* check type cast? */
	2398	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
	2399	if (!tc) return SWIG_ERROR;
	2400	}
	2401	}
	2402	return SWIG_OK;
	2403	}
	2404
	2405	/* -----------------------------------------------------------------------------
	2406	* Create a new pointer object
	2407	* ----------------------------------------------------------------------------- */
	2408
	2409	/*
	2410	Create a new instance object, without calling __init__, and set the
	2411	'this' attribute.
	2412	*/
	2413
	2414	SWIGRUNTIME PyObject*
	2415	SWIG_Python_NewShadowInstance(SwigPyClientData data, PyObject swig_this)
	2416	{
	2417	#if (PY_VERSION_HEX >= 0x02020000)
	2418	PyObject *inst = 0;
	2419	PyObject *newraw = data->newraw;
	2420	if (newraw) {
	2421	inst = PyObject_Call(newraw, data->newargs, NULL);
	2422	if (inst) {
	2423	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
	2424	PyObject **dictptr = _PyObject_GetDictPtr(inst);
	2425	if (dictptr != NULL) {
	2426	PyObject dict = dictptr;
	2427	if (dict == NULL) {
	2428	dict = PyDict_New();
	2429	*dictptr = dict;
	2430	PyDict_SetItem(dict, SWIG_This(), swig_this);
	2431	}
	2432	}
	2433	#else
	2434	PyObject *key = SWIG_This();
	2435	PyObject_SetAttr(inst, key, swig_this);
	2436	#endif
	2437	}
	2438	} else {
	2439	#if PY_VERSION_HEX >= 0x03000000
	2440	inst = ((PyTypeObject) data->newargs)->tp_new((PyTypeObject) data->newargs, Py_None, Py_None);
	2441	if (inst) {
	2442	PyObject_SetAttr(inst, SWIG_This(), swig_this);
	2443	Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
	2444	}
	2445	#else
	2446	PyObject *dict = PyDict_New();
	2447	if (dict) {
	2448	PyDict_SetItem(dict, SWIG_This(), swig_this);
	2449	inst = PyInstance_NewRaw(data->newargs, dict);
	2450	Py_DECREF(dict);
	2451	}
	2452	#endif
	2453	}
	2454	return inst;
	2455	#else
	2456	#if (PY_VERSION_HEX >= 0x02010000)
	2457	PyObject *inst = 0;
	2458	PyObject *dict = PyDict_New();
	2459	if (dict) {
	2460	PyDict_SetItem(dict, SWIG_This(), swig_this);
	2461	inst = PyInstance_NewRaw(data->newargs, dict);
	2462	Py_DECREF(dict);
	2463	}
	2464	return (PyObject *) inst;
	2465	#else
	2466	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
	2467	if (inst == NULL) {
	2468	return NULL;
	2469	}
	2470	inst->in_class = (PyClassObject *)data->newargs;
	2471	Py_INCREF(inst->in_class);
	2472	inst->in_dict = PyDict_New();
	2473	if (inst->in_dict == NULL) {
	2474	Py_DECREF(inst);
	2475	return NULL;
	2476	}
	2477	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
	2478	inst->in_weakreflist = NULL;
	2479	#endif
	2480	#ifdef Py_TPFLAGS_GC
	2481	PyObject_GC_Init(inst);
	2482	#endif
	2483	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
	2484	return (PyObject *) inst;
	2485	#endif
	2486	#endif
	2487	}
	2488
	2489	SWIGRUNTIME void
	2490	SWIG_Python_SetSwigThis(PyObject inst, PyObject swig_this)
	2491	{
	2492	PyObject *dict;
	2493	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
	2494	PyObject **dictptr = _PyObject_GetDictPtr(inst);
	2495	if (dictptr != NULL) {
	2496	dict = *dictptr;
	2497	if (dict == NULL) {
	2498	dict = PyDict_New();
	2499	*dictptr = dict;
	2500	}
	2501	PyDict_SetItem(dict, SWIG_This(), swig_this);
	2502	return;
	2503	}
	2504	#endif
	2505	dict = PyObject_GetAttrString(inst, (char*)"__dict__");
	2506	PyDict_SetItem(dict, SWIG_This(), swig_this);
	2507	Py_DECREF(dict);
	2508	}
	2509
	2510
	2511	SWIGINTERN PyObject *
	2512	SWIG_Python_InitShadowInstance(PyObject *args) {
	2513	PyObject *obj[2];
	2514	if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
	2515	return NULL;
	2516	} else {
	2517	SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
	2518	if (sthis) {
	2519	SwigPyObject_append((PyObject*) sthis, obj[1]);
	2520	} else {
	2521	SWIG_Python_SetSwigThis(obj[0], obj[1]);
	2522	}
	2523	return SWIG_Py_Void();
	2524	}
	2525	}
	2526
	2527	/* Create a new pointer object */
	2528
	2529	SWIGRUNTIME PyObject *
	2530	SWIG_Python_NewPointerObj(PyObject self, void ptr, swig_type_info *type, int flags) {
	2531	SwigPyClientData *clientdata;
	2532	PyObject * robj;
	2533	int own;
	2534
	2535	if (!ptr)
	2536	return SWIG_Py_Void();
	2537
	2538	clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
	2539	own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
	2540	if (clientdata && clientdata->pytype) {
	2541	SwigPyObject *newobj;
	2542	if (flags & SWIG_BUILTIN_TP_INIT) {
	2543	newobj = (SwigPyObject*) self;
	2544	if (newobj->ptr) {
	2545	PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
	2546	while (newobj->next)
	2547	newobj = (SwigPyObject *) newobj->next;
	2548	newobj->next = next_self;
	2549	newobj = (SwigPyObject *)next_self;
	2550	}
	2551	} else {
	2552	newobj = PyObject_New(SwigPyObject, clientdata->pytype);
	2553	}
	2554	if (newobj) {
	2555	newobj->ptr = ptr;
	2556	newobj->ty = type;
	2557	newobj->own = own;
	2558	newobj->next = 0;
	2559	#ifdef SWIGPYTHON_BUILTIN
	2560	newobj->dict = 0;
	2561	#endif
	2562	return (PyObject*) newobj;
	2563	}
	2564	return SWIG_Py_Void();
	2565	}
	2566
	2567	assert(!(flags & SWIG_BUILTIN_TP_INIT));
	2568
	2569	robj = SwigPyObject_New(ptr, type, own);
	2570	if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
	2571	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
	2572	Py_DECREF(robj);
	2573	robj = inst;
	2574	}
	2575	return robj;
	2576	}
	2577
	2578	/* Create a new packed object */
	2579
	2580	SWIGRUNTIMEINLINE PyObject *
	2581	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
	2582	return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
	2583	}
	2584
	2585	/* -----------------------------------------------------------------------------*
	2586	* Get type list
	2587	* -----------------------------------------------------------------------------*/
	2588
	2589	#ifdef SWIG_LINK_RUNTIME
	2590	void SWIG_ReturnGlobalTypeList(void );
	2591	#endif
	2592
	2593	SWIGRUNTIME swig_module_info *
	2594	SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
	2595	static void type_pointer = (void )0;
	2596	/* first check if module already created */
	2597	if (!type_pointer) {
	2598	#ifdef SWIG_LINK_RUNTIME
	2599	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
	2600	#else
	2601	# ifdef SWIGPY_USE_CAPSULE
	2602	type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
	2603	# else
	2604	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
	2605	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
	2606	# endif
	2607	if (PyErr_Occurred()) {
	2608	PyErr_Clear();
	2609	type_pointer = (void *)0;
	2610	}
	2611	#endif
	2612	}
	2613	return (swig_module_info *) type_pointer;
	2614	}
	2615
	2616	#if PY_MAJOR_VERSION < 2
	2617	/* PyModule_AddObject function was introduced in Python 2.0. The following function
	2618	is copied out of Python/modsupport.c in python version 2.3.4 */
	2619	SWIGINTERN int
	2620	PyModule_AddObject(PyObject m, char name, PyObject *o)
	2621	{
	2622	PyObject *dict;
	2623	if (!PyModule_Check(m)) {
	2624	PyErr_SetString(PyExc_TypeError,
	2625	"PyModule_AddObject() needs module as first arg");
	2626	return SWIG_ERROR;
	2627	}
	2628	if (!o) {
	2629	PyErr_SetString(PyExc_TypeError,
	2630	"PyModule_AddObject() needs non-NULL value");
	2631	return SWIG_ERROR;
	2632	}
	2633
	2634	dict = PyModule_GetDict(m);
	2635	if (dict == NULL) {
	2636	/* Internal error -- modules must have a dict! */
	2637	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
	2638	PyModule_GetName(m));
	2639	return SWIG_ERROR;
	2640	}
	2641	if (PyDict_SetItemString(dict, name, o))
	2642	return SWIG_ERROR;
	2643	Py_DECREF(o);
	2644	return SWIG_OK;
	2645	}
	2646	#endif
	2647
	2648	SWIGRUNTIME void
	2649	#ifdef SWIGPY_USE_CAPSULE
	2650	SWIG_Python_DestroyModule(PyObject *obj)
	2651	#else
	2652	SWIG_Python_DestroyModule(void *vptr)
	2653	#endif
	2654	{
	2655	#ifdef SWIGPY_USE_CAPSULE
	2656	swig_module_info swig_module = (swig_module_info ) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
	2657	#else
	2658	swig_module_info swig_module = (swig_module_info ) vptr;
	2659	#endif
	2660	swig_type_info **types = swig_module->types;
	2661	size_t i;
	2662	for (i =0; i < swig_module->size; ++i) {
	2663	swig_type_info *ty = types[i];
	2664	if (ty->owndata) {
	2665	SwigPyClientData data = (SwigPyClientData ) ty->clientdata;
	2666	if (data) SwigPyClientData_Del(data);
	2667	}
	2668	}
	2669	Py_DECREF(SWIG_This());
	2670	swig_this = NULL;
	2671	}
	2672
	2673	SWIGRUNTIME void
	2674	SWIG_Python_SetModule(swig_module_info *swig_module) {
	2675	#if PY_VERSION_HEX >= 0x03000000
	2676	/* Add a dummy module object into sys.modules */
	2677	PyObject module = PyImport_AddModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION);
	2678	#else
	2679	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
	2680	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
	2681	#endif
	2682	#ifdef SWIGPY_USE_CAPSULE
	2683	PyObject pointer = PyCapsule_New((void ) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
	2684	if (pointer && module) {
	2685	PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
	2686	} else {
	2687	Py_XDECREF(pointer);
	2688	}
	2689	#else
	2690	PyObject pointer = PyCObject_FromVoidPtr((void ) swig_module, SWIG_Python_DestroyModule);
	2691	if (pointer && module) {
	2692	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
	2693	} else {
	2694	Py_XDECREF(pointer);
	2695	}
	2696	#endif
	2697	}
	2698
	2699	/* The python cached type query */
	2700	SWIGRUNTIME PyObject *
	2701	SWIG_Python_TypeCache(void) {
	2702	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
	2703	return cache;
	2704	}
	2705
	2706	SWIGRUNTIME swig_type_info *
	2707	SWIG_Python_TypeQuery(const char *type)
	2708	{
	2709	PyObject *cache = SWIG_Python_TypeCache();
	2710	PyObject *key = SWIG_Python_str_FromChar(type);
	2711	PyObject *obj = PyDict_GetItem(cache, key);
	2712	swig_type_info *descriptor;
	2713	if (obj) {
	2714	#ifdef SWIGPY_USE_CAPSULE
	2715	descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
	2716	#else
	2717	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
	2718	#endif
	2719	} else {
	2720	swig_module_info *swig_module = SWIG_GetModule(0);
	2721	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
	2722	if (descriptor) {
	2723	#ifdef SWIGPY_USE_CAPSULE
	2724	obj = PyCapsule_New((void*) descriptor, NULL, NULL);
	2725	#else
	2726	obj = PyCObject_FromVoidPtr(descriptor, NULL);
	2727	#endif
	2728	PyDict_SetItem(cache, key, obj);
	2729	Py_DECREF(obj);
	2730	}
	2731	}
	2732	Py_DECREF(key);
	2733	return descriptor;
	2734	}
	2735
	2736	/*
	2737	For backward compatibility only
	2738	*/
	2739	#define SWIG_POINTER_EXCEPTION 0
	2740	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
	2741	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
	2742
	2743	SWIGRUNTIME int
	2744	SWIG_Python_AddErrMesg(const char* mesg, int infront)
	2745	{
	2746	if (PyErr_Occurred()) {
	2747	PyObject *type = 0;
	2748	PyObject *value = 0;
	2749	PyObject *traceback = 0;
	2750	PyErr_Fetch(&type, &value, &traceback);
	2751	if (value) {
	2752	char *tmp;
	2753	PyObject *old_str = PyObject_Str(value);
	2754	Py_XINCREF(type);
	2755	PyErr_Clear();
	2756	if (infront) {
	2757	PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
	2758	} else {
	2759	PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
	2760	}
	2761	SWIG_Python_str_DelForPy3(tmp);
	2762	Py_DECREF(old_str);
	2763	}
	2764	return 1;
	2765	} else {
	2766	return 0;
	2767	}
	2768	}
	2769
	2770	SWIGRUNTIME int
	2771	SWIG_Python_ArgFail(int argnum)
	2772	{
	2773	if (PyErr_Occurred()) {
	2774	/* add information about failing argument */
	2775	char mesg[256];
	2776	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
	2777	return SWIG_Python_AddErrMesg(mesg, 1);
	2778	} else {
	2779	return 0;
	2780	}
	2781	}
	2782
	2783	SWIGRUNTIMEINLINE const char *
	2784	SwigPyObject_GetDesc(PyObject *self)
	2785	{
	2786	SwigPyObject v = (SwigPyObject )self;
	2787	swig_type_info *ty = v ? v->ty : 0;
	2788	return ty ? ty->str : "";
	2789	}
	2790
	2791	SWIGRUNTIME void
	2792	SWIG_Python_TypeError(const char type, PyObject obj)
	2793	{
	2794	if (type) {
	2795	#if defined(SWIG_COBJECT_TYPES)
	2796	if (obj && SwigPyObject_Check(obj)) {
	2797	const char otype = (const char ) SwigPyObject_GetDesc(obj);
	2798	if (otype) {
	2799	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
	2800	type, otype);
	2801	return;
	2802	}
	2803	} else
	2804	#endif
	2805	{
	2806	const char *otype = (obj ? obj->ob_type->tp_name : 0);
	2807	if (otype) {
	2808	PyObject *str = PyObject_Str(obj);
	2809	const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
	2810	if (cstr) {
	2811	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
	2812	type, otype, cstr);
	2813	SWIG_Python_str_DelForPy3(cstr);
	2814	} else {
	2815	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
	2816	type, otype);
	2817	}
	2818	Py_XDECREF(str);
	2819	return;
	2820	}
	2821	}
	2822	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
	2823	} else {
	2824	PyErr_Format(PyExc_TypeError, "unexpected type is received");
	2825	}
	2826	}
	2827
	2828
	2829	/* Convert a pointer value, signal an exception on a type mismatch */
	2830	SWIGRUNTIME void *
	2831	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int SWIGUNUSEDPARM(argnum), int flags) {
	2832	void *result;
	2833	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
	2834	PyErr_Clear();
	2835	#if SWIG_POINTER_EXCEPTION
	2836	if (flags) {
	2837	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
	2838	SWIG_Python_ArgFail(argnum);
	2839	}
	2840	#endif
	2841	}
	2842	return result;
	2843	}
	2844
	2845	#ifdef SWIGPYTHON_BUILTIN
	2846	SWIGRUNTIME int
	2847	SWIG_Python_NonDynamicSetAttr(PyObject obj, PyObject name, PyObject *value) {
	2848	PyTypeObject *tp = obj->ob_type;
	2849	PyObject *descr;
	2850	PyObject *encoded_name;
	2851	descrsetfunc f;
	2852	int res = -1;
	2853
	2854	# ifdef Py_USING_UNICODE
	2855	if (PyString_Check(name)) {
	2856	name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
	2857	if (!name)
	2858	return -1;
	2859	} else if (!PyUnicode_Check(name))
	2860	# else
	2861	if (!PyString_Check(name))
	2862	# endif
	2863	{
	2864	PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
	2865	return -1;
	2866	} else {
	2867	Py_INCREF(name);
	2868	}
	2869
	2870	if (!tp->tp_dict) {
	2871	if (PyType_Ready(tp) < 0)
	2872	goto done;
	2873	}
	2874
	2875	descr = _PyType_Lookup(tp, name);
	2876	f = NULL;
	2877	if (descr != NULL)
	2878	f = descr->ob_type->tp_descr_set;
	2879	if (!f) {
	2880	if (PyString_Check(name)) {
	2881	encoded_name = name;
	2882	Py_INCREF(name);
	2883	} else {
	2884	encoded_name = PyUnicode_AsUTF8String(name);
	2885	}
	2886	PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
	2887	Py_DECREF(encoded_name);
	2888	} else {
	2889	res = f(descr, obj, value);
	2890	}
	2891
	2892	done:
	2893	Py_DECREF(name);
	2894	return res;
	2895	}
	2896	#endif
	2897
	2898
	2899	#ifdef __cplusplus
	2900	}
	2901	#endif
	2902
	2903
	2904
	2905	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
	2906
	2907	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
	2908
	2909
	2910
	2911	#define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
	2912
	2913
	2914	/* -------- TYPES TABLE (BEGIN) -------- */
	2915
	2916	#define SWIGTYPE_p_char swig_types[0]
	2917	#define SWIGTYPE_p_double swig_types[1]
	2918	#define SWIGTYPE_p_double_complex swig_types[2]
	2919	#define SWIGTYPE_p_int swig_types[3]
	2920	#define SWIGTYPE_p_shtns_info swig_types[4]
	2921	static swig_type_info *swig_types[6];
	2922	static swig_module_info swig_module = {swig_types, 5, 0, 0, 0, 0};
	2923	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
	2924	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
	2925
	2926	/* -------- TYPES TABLE (END) -------- */
	2927
	2928	#if (PY_VERSION_HEX <= 0x02000000)
	2929	# if !defined(SWIG_PYTHON_CLASSIC)
	2930	# error "This python version requires swig to be run with the '-classic' option"
	2931	# endif
	2932	#endif
	2933
	2934	/*-----------------------------------------------
	2935	@(target):= _shtns.so
	2936	------------------------------------------------*/
	2937	#if PY_VERSION_HEX >= 0x03000000
	2938	# define SWIG_init PyInit__shtns
	2939
	2940	#else
	2941	# define SWIG_init init_shtns
	2942
	2943	#endif
	2944	#define SWIG_name "_shtns"
	2945
	2946	#define SWIGVERSION 0x030005
	2947	#define SWIG_VERSION SWIGVERSION
	2948
	2949
	2950	#define SWIG_as_voidptr(a) (void )((const void )(a))
	2951	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(a),(void*)(a))
	2952
	2953
	2954
	2955	#include <numpy/arrayobject.h>
	2956	#include "sht_private.h"
	2957
	2958	// variables used for exception handling.
	2959	static int shtns_error = 0;
	2960	static char* shtns_err_msg;
	2961	static char msg_buffer[128];
	2962	static char msg_grid_err[] = "Grid not set. Call .set_grid() mehtod.";
	2963	static char msg_numpy_arr[] = "Numpy array expected.";
	2964	static char msg_rot_err[] = "truncation must be triangular (lmax=mmax, mres=1)";
	2965
	2966	static void throw_exception(int error, int iarg, char* msg)
	2967	{
	2968	shtns_error = error;
	2969	shtns_err_msg = msg;
	2970	if (iarg > 0) {
	2971	sprintf(msg_buffer, "arg #%d : %.100s", iarg, msg);
	2972	shtns_err_msg = msg_buffer;
	2973	}
	2974	}
	2975
	2976	static int check_spatial(int i, PyObject *a, int size) {
	2977	if (size == 0) {
	2978	throw_exception(SWIG_RuntimeError,0,msg_grid_err); return 0;
	2979	}
	2980	if (!PyArray_Check(a)) {
	2981	throw_exception(SWIG_TypeError,i,msg_numpy_arr); return 0;
	2982	}
	2983	if (PyArray_TYPE(a) != PyArray_DOUBLE) {
	2984	throw_exception(SWIG_TypeError,i,"spatial array must consist of float."); return 0;
	2985	}
	2986	if (!PyArray_ISCONTIGUOUS(a)) {
	2987	throw_exception(SWIG_RuntimeError,i,"spatial array not contiguous. Use 'b=a.copy()' to copy a to a contiguous array b."); return 0;
	2988	}
	2989	if (PyArray_SIZE(a) != size) {
	2990	throw_exception(SWIG_RuntimeError,i,"spatial array has wrong size"); return 0;
	2991	}
	2992	return 1;
	2993	}
	2994
	2995	static int check_spectral(int i, PyObject *a, int size) {
	2996	if (!PyArray_Check(a)) {
	2997	throw_exception(SWIG_RuntimeError,i,msg_numpy_arr); return 0;
	2998	}
	2999	if (PyArray_TYPE(a) != PyArray_CDOUBLE) {
	3000	throw_exception(SWIG_RuntimeError,i,"spectral array must consist of complex float. Create with: 'sh.spec_array()'"); return 0;
	3001	}
	3002	if (!PyArray_ISCONTIGUOUS(a)) {
	3003	throw_exception(SWIG_RuntimeError,i,"spactral array not contiguous. Use .copy() to copy to a contiguous array."); return 0;
	3004	}
	3005	if (PyArray_SIZE(a) != size) {
	3006	throw_exception(SWIG_RuntimeError,i,"spectral array has wrong size"); return 0;
	3007	}
	3008	return 1;
	3009	}
	3010
	3011	inline PyObject* SpecArray_New(int size) {
	3012	npy_intp dims = size;
	3013	npy_intp strides = sizeof(cplx);
	3014	return PyArray_New(&PyArray_Type, 1, &dims, PyArray_CDOUBLE, &strides, NULL, strides, 0, NULL);
	3015	}
	3016
	3017	inline PyObject* SpatArray_New(int size) {
	3018	npy_intp dims = size;
	3019	npy_intp strides = sizeof(double);
	3020	return PyArray_New(&PyArray_Type, 1, &dims, PyArray_DOUBLE, &strides, NULL, strides, 0, NULL);
	3021	}
	3022
	3023
	3024
	3025	SWIGINTERNINLINE PyObject*
	3026	SWIG_From_int (int value)
	3027	{
	3028	return PyInt_FromLong((long) value);
	3029	}
	3030
	3031
	3032	SWIGINTERNINLINE PyObject*
	3033	SWIG_From_unsigned_SS_int (unsigned int value)
	3034	{
	3035	return PyInt_FromSize_t((size_t) value);
	3036	}
	3037
	3038
	3039	#define SWIG_From_long PyLong_FromLong
	3040
	3041
	3042	SWIGINTERNINLINE PyObject*
	3043	SWIG_From_unsigned_SS_long (unsigned long value)
	3044	{
	3045	return (value > LONG_MAX) ?
	3046	PyLong_FromUnsignedLong(value) : PyLong_FromLong((long)(value));
	3047	}
	3048
	3049
	3050	SWIGINTERNINLINE PyObject *
	3051	SWIG_From_unsigned_SS_short (unsigned short value)
	3052	{
	3053	return SWIG_From_unsigned_SS_long (value);
	3054	}
	3055
	3056
	3057	#include <limits.h>
	3058	#if !defined(SWIG_NO_LLONG_MAX)
	3059	# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
	3060	# define LLONG_MAX __LONG_LONG_MAX__
	3061	# define LLONG_MIN (-LLONG_MAX - 1LL)
	3062	# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
	3063	# endif
	3064	#endif
	3065
	3066
	3067	SWIGINTERN int
	3068	SWIG_AsVal_double (PyObject obj, double val)
	3069	{
	3070	int res = SWIG_TypeError;
	3071	if (PyFloat_Check(obj)) {
	3072	if (val) *val = PyFloat_AsDouble(obj);
	3073	return SWIG_OK;
	3074	} else if (PyInt_Check(obj)) {
	3075	if (val) *val = PyInt_AsLong(obj);
	3076	return SWIG_OK;
	3077	} else if (PyLong_Check(obj)) {
	3078	double v = PyLong_AsDouble(obj);
	3079	if (!PyErr_Occurred()) {
	3080	if (val) *val = v;
	3081	return SWIG_OK;
	3082	} else {
	3083	PyErr_Clear();
	3084	}
	3085	}
	3086	#ifdef SWIG_PYTHON_CAST_MODE
	3087	{
	3088	int dispatch = 0;
	3089	double d = PyFloat_AsDouble(obj);
	3090	if (!PyErr_Occurred()) {
	3091	if (val) *val = d;
	3092	return SWIG_AddCast(SWIG_OK);
	3093	} else {
	3094	PyErr_Clear();
	3095	}
	3096	if (!dispatch) {
	3097	long v = PyLong_AsLong(obj);
	3098	if (!PyErr_Occurred()) {
	3099	if (val) *val = v;
	3100	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
	3101	} else {
	3102	PyErr_Clear();
	3103	}
	3104	}
	3105	}
	3106	#endif
	3107	return res;
	3108	}
	3109
	3110
	3111	#include <float.h>
	3112
	3113
	3114	#include <math.h>
	3115
	3116
	3117	SWIGINTERNINLINE int
	3118	SWIG_CanCastAsInteger(double *d, double min, double max) {
	3119	double x = *d;
	3120	if ((min <= x && x <= max)) {
	3121	double fx = floor(x);
	3122	double cx = ceil(x);
	3123	double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
	3124	if ((errno == EDOM) \|\| (errno == ERANGE)) {
	3125	errno = 0;
	3126	} else {
	3127	double summ, reps, diff;
	3128	if (rd < x) {
	3129	diff = x - rd;
	3130	} else if (rd > x) {
	3131	diff = rd - x;
	3132	} else {
	3133	return 1;
	3134	}
	3135	summ = rd + x;
	3136	reps = diff/summ;
	3137	if (reps < 8*DBL_EPSILON) {
	3138	*d = rd;
	3139	return 1;
	3140	}
	3141	}
	3142	}
	3143	return 0;
	3144	}
	3145
	3146
	3147	SWIGINTERN int
	3148	SWIG_AsVal_long (PyObject obj, long val)
	3149	{
	3150	if (PyInt_Check(obj)) {
	3151	if (val) *val = PyInt_AsLong(obj);
	3152	return SWIG_OK;
	3153	} else if (PyLong_Check(obj)) {
	3154	long v = PyLong_AsLong(obj);
	3155	if (!PyErr_Occurred()) {
	3156	if (val) *val = v;
	3157	return SWIG_OK;
	3158	} else {
	3159	PyErr_Clear();
	3160	}
	3161	}
	3162	#ifdef SWIG_PYTHON_CAST_MODE
	3163	{
	3164	int dispatch = 0;
	3165	long v = PyInt_AsLong(obj);
	3166	if (!PyErr_Occurred()) {
	3167	if (val) *val = v;
	3168	return SWIG_AddCast(SWIG_OK);
	3169	} else {
	3170	PyErr_Clear();
	3171	}
	3172	if (!dispatch) {
	3173	double d;
	3174	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
	3175	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
	3176	if (val) *val = (long)(d);
	3177	return res;
	3178	}
	3179	}
	3180	}
	3181	#endif
	3182	return SWIG_TypeError;
	3183	}
	3184
	3185
	3186	SWIGINTERN int
	3187	SWIG_AsVal_int (PyObject * obj, int *val)
	3188	{
	3189	long v;
	3190	int res = SWIG_AsVal_long (obj, &v);
	3191	if (SWIG_IsOK(res)) {
	3192	if ((v < INT_MIN \|\| v > INT_MAX)) {
	3193	return SWIG_OverflowError;
	3194	} else {
	3195	if (val) *val = (int)(v);
	3196	}
	3197	}
	3198	return res;
	3199	}
	3200
	3201	SWIGINTERN struct shtns_info *new_shtns_info(int lmax,int mmax,int mres,int norm,int nthreads){ // default arguments : mmax, mres and norm
	3202	if (lmax < 2) {
	3203	throw_exception(SWIG_ValueError,1,"lmax < 2 not allowed"); return NULL;
	3204	}
	3205	if (mres <= 0) {
	3206	throw_exception(SWIG_ValueError,3,"mres <= 0 invalid"); return NULL;
	3207	}
	3208	if (mmax < 0) mmax = lmax/mres; // default mmax
	3209	if (mmax*mres > lmax) {
	3210	throw_exception(SWIG_ValueError,1,"lmax < mmax*mres invalid"); return NULL;
	3211	}
	3212	shtns_use_threads(nthreads); // use nthreads openmp threads if available (0 means auto)
	3213	return shtns_create(lmax, mmax, mres, norm);
	3214	}
	3215	SWIGINTERN void delete_shtns_info(struct shtns_info *self){
	3216	shtns_destroy(self); // free memory.
	3217	}
	3218	SWIGINTERN void shtns_info_set_grid(struct shtns_info self,int nlat,int nphi,int flags,double polar_opt,int nl_order,int nlat_out,int *nphi_out){ // default arguments
	3219	if (nlat != 0) {
	3220	if (nlat <= self->lmax) { // nlat too small
	3221	throw_exception(SWIG_ValueError,1,"nlat <= lmax"); return;
	3222	}
	3223	if (nlat & 1) { // nlat must be even
	3224	throw_exception(SWIG_ValueError,1,"nlat must be even"); return;
	3225	}
	3226	}
	3227	if ((nphi != 0) && (nphi <= self->mmax *2)) { // nphi too small
	3228	throw_exception(SWIG_ValueError,2,"nphi <= 2*mmax"); return;
	3229	}
	3230	if (!(flags & 256)) flags \|= (256*2); // default to SHT_PHI_CONTIGUOUS.
	3231	nlat_out = nlat; nphi_out = nphi;
	3232	shtns_set_grid_auto(self, flags, polar_opt, nl_order, nlat_out, nphi_out);
	3233	}
	3234	SWIGINTERN void shtns_info_print_info(struct shtns_info *self){
	3235	shtns_print_cfg(self);
	3236	}
	3237	SWIGINTERN double shtns_info_sh00_1(struct shtns_info *self){
	3238	return sh00_1(self);
	3239	}
	3240
	3241	#define SWIG_From_double PyFloat_FromDouble
	3242
	3243	SWIGINTERN double shtns_info_sh10_ct(struct shtns_info *self){
	3244	return sh10_ct(self);
	3245	}
	3246	SWIGINTERN double shtns_info_sh11_st(struct shtns_info *self){
	3247	return sh11_st(self);
	3248	}
	3249
	3250	SWIGINTERN int
	3251	SWIG_AsVal_unsigned_SS_long (PyObject obj, unsigned long val)
	3252	{
	3253	#if PY_VERSION_HEX < 0x03000000
	3254	if (PyInt_Check(obj)) {
	3255	long v = PyInt_AsLong(obj);
	3256	if (v >= 0) {
	3257	if (val) *val = v;
	3258	return SWIG_OK;
	3259	} else {
	3260	return SWIG_OverflowError;
	3261	}
	3262	} else
	3263	#endif
	3264	if (PyLong_Check(obj)) {
	3265	unsigned long v = PyLong_AsUnsignedLong(obj);
	3266	if (!PyErr_Occurred()) {
	3267	if (val) *val = v;
	3268	return SWIG_OK;
	3269	} else {
	3270	PyErr_Clear();
	3271	#if PY_VERSION_HEX >= 0x03000000
	3272	{
	3273	long v = PyLong_AsLong(obj);
	3274	if (!PyErr_Occurred()) {
	3275	if (v < 0) {
	3276	return SWIG_OverflowError;
	3277	}
	3278	} else {
	3279	PyErr_Clear();
	3280	}
	3281	}
	3282	#endif
	3283	}
	3284	}
	3285	#ifdef SWIG_PYTHON_CAST_MODE
	3286	{
	3287	int dispatch = 0;
	3288	unsigned long v = PyLong_AsUnsignedLong(obj);
	3289	if (!PyErr_Occurred()) {
	3290	if (val) *val = v;
	3291	return SWIG_AddCast(SWIG_OK);
	3292	} else {
	3293	PyErr_Clear();
	3294	}
	3295	if (!dispatch) {
	3296	double d;
	3297	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
	3298	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
	3299	if (val) *val = (unsigned long)(d);
	3300	return res;
	3301	}
	3302	}
	3303	}
	3304	#endif
	3305	return SWIG_TypeError;
	3306	}
	3307
	3308
	3309	SWIGINTERN int
	3310	SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
	3311	{
	3312	unsigned long v;
	3313	int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
	3314	if (SWIG_IsOK(res)) {
	3315	if ((v > UINT_MAX)) {
	3316	return SWIG_OverflowError;
	3317	} else {
	3318	if (val) *val = (unsigned int)(v);
	3319	}
	3320	}
	3321	return res;
	3322	}
	3323
	3324	SWIGINTERN double shtns_info_shlm_e1(struct shtns_info *self,unsigned int l,unsigned int m){
	3325	return shlm_e1(self, l, m);
	3326	}
	3327	SWIGINTERN PyObject shtns_info___ct(struct shtns_info self){ // grid must have been initialized.
	3328	PyObject *obj;
	3329	double *ct;
	3330	int i;
	3331	if (self->nlat == 0) { // no grid
	3332	throw_exception(SWIG_RuntimeError,0,msg_grid_err);
	3333	return NULL;
	3334	}
	3335	obj = SpatArray_New(self->nlat);
	3336	ct = (double*) PyArray_DATA(obj);
	3337	for (i=0; i<self->nlat; i++) ct[i] = self->ct[i]; // copy
	3338	return obj;
	3339	}
	3340	SWIGINTERN PyObject shtns_info_gauss_wts(struct shtns_info self){ // gauss grid must have been initialized.
	3341	PyObject *obj;
	3342	if (self->nlat == 0) { // no grid
	3343	throw_exception(SWIG_RuntimeError,0,msg_grid_err);
	3344	return NULL;
	3345	}
	3346	if (self->wg == NULL) {
	3347	throw_exception(SWIG_RuntimeError,0,"not a gauss grid");
	3348	return NULL;
	3349	}
	3350	obj = SpatArray_New(self->nlat_2);
	3351	shtns_gauss_wts(self, PyArray_DATA(obj));
	3352	return obj;
	3353	}
	3354	SWIGINTERN PyObject shtns_info_mul_ct_matrix(struct shtns_info self){
	3355	PyObject mx = SpatArray_New(2self->nlm);
	3356	mul_ct_matrix(self, PyArray_DATA(mx));
	3357	return mx;
	3358	}
	3359	SWIGINTERN PyObject shtns_info_st_dt_matrix(struct shtns_info self){
	3360	PyObject mx = SpatArray_New(2self->nlm);
	3361	st_dt_matrix(self, PyArray_DATA(mx));
	3362	return mx;
	3363	}
	3364	SWIGINTERN void shtns_info___spat_shape(struct shtns_info self,int dim0,int *dim1){
	3365	dim0 = self->nphi; dim1 = self->nlat;
	3366	if (self->fftc_mode == 1) { // phi-contiguous
	3367	dim0 = self->nlat; dim1 = self->nphi;
	3368	}
	3369	}
	3370	SWIGINTERN int shtns_info_idx(struct shtns_info *self,unsigned int l,unsigned int m){
	3371	if (l > self->lmax) {
	3372	throw_exception(SWIG_ValueError,1,"l invalid"); return 0;
	3373	}
	3374	if ( (m > l) \|\| (m > self->mmax * self->mres) \|\| (m % self->mres != 0) ) {
	3375	throw_exception(SWIG_ValueError,2,"m invalid"); return 0;
	3376	}
	3377	return ( self->lmidx[((unsigned)(m))/self->mres] + (l) );
	3378	}
	3379	SWIGINTERN void shtns_info_spat_to_SH(struct shtns_info self,PyObject Vr,PyObject *Qlm){
	3380	if (check_spatial(1,Vr, self->nspat) && check_spectral(2,Qlm, self->nlm))
	3381	spat_to_SH(self, PyArray_DATA(Vr), PyArray_DATA(Qlm));
	3382	}
	3383	SWIGINTERN void shtns_info_SH_to_spat(struct shtns_info self,PyObject Qlm,PyObject *Vr){
	3384	if (check_spatial(2,Vr, self->nspat) && check_spectral(1,Qlm, self->nlm))
	3385	SH_to_spat(self, PyArray_DATA(Qlm), PyArray_DATA(Vr));
	3386	}
	3387	SWIGINTERN void shtns_info_spat_cplx_to_SH(struct shtns_info self,PyObject z,PyObject *alm){
	3388	int n = self->lmax + 1;
	3389	if (check_spectral(1,z, self->nspat) && check_spectral(2,alm, n*n))
	3390	spat_cplx_to_SH(self, PyArray_DATA(z), PyArray_DATA(alm));
	3391	}
	3392	SWIGINTERN void shtns_info_SH_to_spat_cplx(struct shtns_info self,PyObject alm,PyObject *z){
	3393	int n = self->lmax + 1;
	3394	if (check_spectral(2,z, self->nspat) && check_spectral(1,alm, n*n))
	3395	SH_to_spat_cplx(self, PyArray_DATA(alm), PyArray_DATA(z));
	3396	}
	3397	SWIGINTERN void shtns_info_spat_to_SHsphtor(struct shtns_info self,PyObject Vt,PyObject Vp,PyObject Slm,PyObject *Tlm){
	3398	if (check_spatial(1,Vt, self->nspat) && check_spatial(2,Vp, self->nspat) && check_spectral(3,Slm, self->nlm) && check_spectral(4,Tlm, self->nlm))
	3399	spat_to_SHsphtor(self, PyArray_DATA(Vt), PyArray_DATA(Vp), PyArray_DATA(Slm), PyArray_DATA(Tlm));
	3400	}
	3401	SWIGINTERN void shtns_info_SHsphtor_to_spat(struct shtns_info self,PyObject Slm,PyObject Tlm,PyObject Vt,PyObject *Vp){
	3402	if (check_spatial(3,Vt, self->nspat) && check_spatial(4,Vp, self->nspat) && check_spectral(1,Slm, self->nlm) && check_spectral(2,Tlm, self->nlm))
	3403	SHsphtor_to_spat(self, PyArray_DATA(Slm), PyArray_DATA(Tlm), PyArray_DATA(Vt), PyArray_DATA(Vp));
	3404	}
	3405	SWIGINTERN void shtns_info_SHsph_to_spat(struct shtns_info self,PyObject Slm,PyObject Vt,PyObject Vp){
	3406	if (check_spatial(2,Vt, self->nspat) && check_spatial(3,Vp, self->nspat) && check_spectral(1,Slm, self->nlm))
	3407	SHsph_to_spat(self, PyArray_DATA(Slm), PyArray_DATA(Vt), PyArray_DATA(Vp));
	3408	}
	3409	SWIGINTERN void shtns_info_SHtor_to_spat(struct shtns_info self,PyObject Tlm,PyObject Vt,PyObject Vp){
	3410	if (check_spatial(2,Vt, self->nspat) && check_spatial(3,Vp, self->nspat) && check_spectral(1,Tlm, self->nlm))
	3411	SHtor_to_spat(self, PyArray_DATA(Tlm), PyArray_DATA(Vt), PyArray_DATA(Vp));
	3412	}
	3413	SWIGINTERN void shtns_info_spat_to_SHqst(struct shtns_info self,PyObject Vr,PyObject Vt,PyObject Vp,PyObject Qlm,PyObject Slm,PyObject *Tlm){
	3414	if (check_spatial(1,Vr, self->nspat) && check_spatial(2,Vt, self->nspat) && check_spatial(3,Vp, self->nspat)
	3415	&& check_spectral(4,Qlm, self->nlm) && check_spectral(5,Slm, self->nlm) && check_spectral(6,Tlm, self->nlm))
	3416	spat_to_SHqst(self, PyArray_DATA(Vr), PyArray_DATA(Vt), PyArray_DATA(Vp), PyArray_DATA(Qlm), PyArray_DATA(Slm), PyArray_DATA(Tlm));
	3417	}
	3418	SWIGINTERN void shtns_info_SHqst_to_spat(struct shtns_info self,PyObject Qlm,PyObject Slm,PyObject Tlm,PyObject Vr,PyObject Vt,PyObject *Vp){
	3419	if (check_spatial(4,Vr, self->nspat) && check_spatial(5,Vt, self->nspat) && check_spatial(6,Vp, self->nspat)
	3420	&& check_spectral(1,Qlm, self->nlm) && check_spectral(2,Slm, self->nlm) && check_spectral(3,Tlm, self->nlm))
	3421	SHqst_to_spat(self, PyArray_DATA(Qlm), PyArray_DATA(Slm), PyArray_DATA(Tlm), PyArray_DATA(Vr), PyArray_DATA(Vt), PyArray_DATA(Vp));
	3422	}
	3423	SWIGINTERN double shtns_info_SH_to_point(struct shtns_info self,PyObject Qlm,double cost,double phi){
	3424	if (check_spectral(1,Qlm, self->nlm)) return SH_to_point(self, PyArray_DATA(Qlm), cost, phi);
	3425	return 0.0;
	3426	}
	3427	SWIGINTERN void shtns_info_SH_to_grad_point(struct shtns_info self,PyObject DrSlm,PyObject Slm,double cost,double phi,double vr,double vt,double vp){
	3428	if (check_spectral(1,DrSlm, self->nlm) && check_spectral(2,Slm, self->nlm))
	3429	SH_to_grad_point(self, PyArray_DATA(DrSlm), PyArray_DATA(Slm), cost, phi, vr, vt, vp);
	3430	}
	3431	SWIGINTERN void shtns_info_SHqst_to_point(struct shtns_info self,PyObject Qlm,PyObject Slm,PyObject Tlm,double cost,double phi,double vr,double vt,double *vp){
	3432	if (check_spectral(1,Qlm, self->nlm) && check_spectral(2,Slm, self->nlm) && check_spectral(3,Tlm, self->nlm))
	3433	SHqst_to_point(self, PyArray_DATA(Qlm), PyArray_DATA(Slm), PyArray_DATA(Tlm), cost, phi, vr, vt, vp);
	3434	}
	3435	SWIGINTERN PyObject shtns_info_Zrotate(struct shtns_info self,PyObject *Qlm,double alpha){
	3436	if (check_spectral(1,Qlm, self->nlm)) {
	3437	PyObject *Rlm = SpecArray_New(self->nlm);
	3438	SH_Zrotate(self, PyArray_DATA(Qlm), alpha, PyArray_DATA(Rlm));
	3439	return Rlm;
	3440	}
	3441	return NULL;
	3442	}
	3443	SWIGINTERN PyObject shtns_info_Yrotate(struct shtns_info self,PyObject *Qlm,double alpha){
	3444	if ((self->mres != 1)\|\|(self->mmax != self->lmax)) {
	3445	throw_exception(SWIG_RuntimeError,0,msg_rot_err); return NULL;
	3446	}
	3447	if (check_spectral(1,Qlm, self->nlm)) {
	3448	PyObject *Rlm = SpecArray_New(self->nlm);
	3449	SH_Yrotate(self, PyArray_DATA(Qlm), alpha, PyArray_DATA(Rlm));
	3450	return Rlm;
	3451	}
	3452	return NULL;
	3453	}
	3454	SWIGINTERN PyObject shtns_info_Yrotate90(struct shtns_info self,PyObject *Qlm){
	3455	if ((self->mres != 1)\|\|(self->mmax != self->lmax)) {
	3456	throw_exception(SWIG_RuntimeError,0,msg_rot_err); return NULL;
	3457	}
	3458	if (check_spectral(1,Qlm, self->nlm)) {
	3459	PyObject *Rlm = SpecArray_New(self->nlm);
	3460	SH_Yrotate90(self, PyArray_DATA(Qlm), PyArray_DATA(Rlm));
	3461	return Rlm;
	3462	}
	3463	return NULL;
	3464	}
	3465	SWIGINTERN PyObject shtns_info_Xrotate90(struct shtns_info self,PyObject *Qlm){
	3466	if ((self->mres != 1)\|\|(self->mmax != self->lmax)) {
	3467	throw_exception(SWIG_RuntimeError,0,msg_rot_err); return NULL;
	3468	}
	3469	if (check_spectral(1,Qlm, self->nlm)) {
	3470	PyObject *Rlm = SpecArray_New(self->nlm);
	3471	SH_Xrotate90(self, PyArray_DATA(Qlm), PyArray_DATA(Rlm));
	3472	return Rlm;
	3473	}
	3474	return NULL;
	3475	}
	3476	SWIGINTERN PyObject shtns_info_SH_mul_mx(struct shtns_info self,PyObject mx,PyObject Qlm){
	3477	if (check_spectral(2,Qlm, self->nlm) && check_spatial(1, mx, 2* self->nlm)) {
	3478	PyObject *Rlm = SpecArray_New(self->nlm);
	3479	SH_mul_mx(self, PyArray_DATA(mx), PyArray_DATA(Qlm), PyArray_DATA(Rlm));
	3480	return Rlm;
	3481	}
	3482	return NULL;
	3483	}
	3484	SWIGINTERN void shtns_info_spat_to_SH_m(struct shtns_info self,PyObject Vr,PyObject Qlm,PyObject im){
	3485	int im_ = PyLong_AsLong(im); int ltr = self->lmax;
	3486	if ((im_ >= 0) && check_spectral(1,Vr, self->nlat) && check_spectral(2,Qlm, ltr+1 - im_*self->mres))
	3487	spat_to_SH_ml(self, im_, PyArray_DATA(Vr), PyArray_DATA(Qlm), ltr);
	3488	}
	3489	SWIGINTERN void shtns_info_SH_to_spat_m(struct shtns_info self,PyObject Qlm,PyObject Vr,PyObject im){
	3490	int im_ = PyLong_AsLong(im); int ltr = self->lmax;
	3491	if ((im_ >= 0) && check_spectral(2,Vr, self->nlat) && check_spectral(1,Qlm, ltr+1 - im_*self->mres))
	3492	SH_to_spat_ml(self, im_, PyArray_DATA(Qlm), PyArray_DATA(Vr), ltr);
	3493	}
	3494	SWIGINTERN void shtns_info_spat_to_SHsphtor_m(struct shtns_info self,PyObject Vt,PyObject Vp,PyObject Slm,PyObject Tlm,PyObject im){
	3495	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3496	if ((im_ >= 0) && check_spectral(1,Vt, self->nlat) && check_spectral(2,Vp, self->nlat) && check_spectral(3,Slm, nelem) && check_spectral(4,Tlm, nelem))
	3497	spat_to_SHsphtor_ml(self, im_, PyArray_DATA(Vt), PyArray_DATA(Vp), PyArray_DATA(Slm), PyArray_DATA(Tlm), ltr);
	3498	}
	3499	SWIGINTERN void shtns_info_SHsphtor_to_spat_m(struct shtns_info self,PyObject Slm,PyObject Tlm,PyObject Vt,PyObject Vp,PyObject im){
	3500	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3501	if ((im_ >= 0) && check_spectral(3,Vt, self->nlat) && check_spectral(4,Vp, self->nlat) && check_spectral(1,Slm, nelem) && check_spectral(2,Tlm, nelem))
	3502	SHsphtor_to_spat_ml(self, im_, PyArray_DATA(Slm), PyArray_DATA(Tlm), PyArray_DATA(Vt), PyArray_DATA(Vp), ltr);
	3503	}
	3504	SWIGINTERN void shtns_info_SHsph_to_spat_m(struct shtns_info self,PyObject Slm,PyObject Vt,PyObject Vp,PyObject *im){
	3505	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3506	if ((im_ >= 0) && check_spectral(2,Vt, self->nlat) && check_spectral(3,Vp, self->nlat) && check_spectral(1,Slm, nelem))
	3507	SHsph_to_spat_ml(self, im_, PyArray_DATA(Slm), PyArray_DATA(Vt), PyArray_DATA(Vp), ltr);
	3508	}
	3509	SWIGINTERN void shtns_info_SHtor_to_spat_m(struct shtns_info self,PyObject Tlm,PyObject Vt,PyObject Vp,PyObject *im){
	3510	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3511	if ((im_ >= 0) && check_spectral(2,Vt, self->nlat) && check_spectral(3,Vp, self->nlat) && check_spectral(1,Tlm, nelem))
	3512	SHtor_to_spat_ml(self, im_, PyArray_DATA(Tlm), PyArray_DATA(Vt), PyArray_DATA(Vp), ltr);
	3513	}
	3514	SWIGINTERN void shtns_info_spat_to_SHqst_m(struct shtns_info self,PyObject Vr,PyObject Vt,PyObject Vp,PyObject Qlm,PyObject Slm,PyObject Tlm,PyObject im){
	3515	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3516	if ((im_ >= 0) && check_spectral(1,Vr, self->nlat) && check_spectral(2,Vt, self->nlat) && check_spectral(3,Vp, self->nlat)
	3517	&& check_spectral(4,Qlm, nelem) && check_spectral(5,Slm, nelem) && check_spectral(6,Tlm, nelem))
	3518	spat_to_SHqst_ml(self, im_, PyArray_DATA(Vr), PyArray_DATA(Vt), PyArray_DATA(Vp), PyArray_DATA(Qlm), PyArray_DATA(Slm), PyArray_DATA(Tlm), ltr);
	3519	}
	3520	SWIGINTERN void shtns_info_SHqst_to_spat_m(struct shtns_info self,PyObject Qlm,PyObject Slm,PyObject Tlm,PyObject Vr,PyObject Vt,PyObject Vp,PyObject im){
	3521	int im_ = PyLong_AsLong(im); int ltr = self->lmax; int nelem = ltr+1 - im_*self->mres;
	3522	if ((im_ >= 0) && check_spectral(4,Vr, self->nlat) && check_spectral(5,Vt, self->nlat) && check_spectral(6,Vp, self->nlat)
	3523	&& check_spectral(1,Qlm, nelem) && check_spectral(2,Slm, nelem) && check_spectral(3,Tlm, nelem))
	3524	SHqst_to_spat_ml(self, im_, PyArray_DATA(Qlm), PyArray_DATA(Slm), PyArray_DATA(Tlm), PyArray_DATA(Vr), PyArray_DATA(Vt), PyArray_DATA(Vp), ltr);
	3525	}
	3526	#ifdef __cplusplus
	3527	extern "C" {
	3528	#endif
	3529	SWIGINTERN PyObject sht_orthonormal_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3530	PyObject *module;
	3531	PyObject *d;
	3532	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3533	d = PyModule_GetDict(module);
	3534	if (!d) return NULL;
	3535	SWIG_Python_SetConstant(d, "sht_orthonormal",SWIG_From_int((int)(sht_orthonormal)));
	3536	return SWIG_Py_Void();
	3537	}
	3538
	3539
	3540	SWIGINTERN PyObject sht_fourpi_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3541	PyObject *module;
	3542	PyObject *d;
	3543	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3544	d = PyModule_GetDict(module);
	3545	if (!d) return NULL;
	3546	SWIG_Python_SetConstant(d, "sht_fourpi",SWIG_From_int((int)(sht_fourpi)));
	3547	return SWIG_Py_Void();
	3548	}
	3549
	3550
	3551	SWIGINTERN PyObject sht_schmidt_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3552	PyObject *module;
	3553	PyObject *d;
	3554	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3555	d = PyModule_GetDict(module);
	3556	if (!d) return NULL;
	3557	SWIG_Python_SetConstant(d, "sht_schmidt",SWIG_From_int((int)(sht_schmidt)));
	3558	return SWIG_Py_Void();
	3559	}
	3560
	3561
	3562	SWIGINTERN PyObject SHT_NO_CS_PHASE_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3563	PyObject *module;
	3564	PyObject *d;
	3565	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3566	d = PyModule_GetDict(module);
	3567	if (!d) return NULL;
	3568	SWIG_Python_SetConstant(d, "SHT_NO_CS_PHASE",SWIG_From_int((int)((256*4))));
	3569	return SWIG_Py_Void();
	3570	}
	3571
	3572
	3573	SWIGINTERN PyObject SHT_REAL_NORM_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3574	PyObject *module;
	3575	PyObject *d;
	3576	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3577	d = PyModule_GetDict(module);
	3578	if (!d) return NULL;
	3579	SWIG_Python_SetConstant(d, "SHT_REAL_NORM",SWIG_From_int((int)((256*8))));
	3580	return SWIG_Py_Void();
	3581	}
	3582
	3583
	3584	SWIGINTERN PyObject sht_gauss_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3585	PyObject *module;
	3586	PyObject *d;
	3587	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3588	d = PyModule_GetDict(module);
	3589	if (!d) return NULL;
	3590	SWIG_Python_SetConstant(d, "sht_gauss",SWIG_From_int((int)(sht_gauss)));
	3591	return SWIG_Py_Void();
	3592	}
	3593
	3594
	3595	SWIGINTERN PyObject sht_auto_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3596	PyObject *module;
	3597	PyObject *d;
	3598	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3599	d = PyModule_GetDict(module);
	3600	if (!d) return NULL;
	3601	SWIG_Python_SetConstant(d, "sht_auto",SWIG_From_int((int)(sht_auto)));
	3602	return SWIG_Py_Void();
	3603	}
	3604
	3605
	3606	SWIGINTERN PyObject sht_reg_fast_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3607	PyObject *module;
	3608	PyObject *d;
	3609	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3610	d = PyModule_GetDict(module);
	3611	if (!d) return NULL;
	3612	SWIG_Python_SetConstant(d, "sht_reg_fast",SWIG_From_int((int)(sht_reg_fast)));
	3613	return SWIG_Py_Void();
	3614	}
	3615
	3616
	3617	SWIGINTERN PyObject sht_reg_dct_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3618	PyObject *module;
	3619	PyObject *d;
	3620	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3621	d = PyModule_GetDict(module);
	3622	if (!d) return NULL;
	3623	SWIG_Python_SetConstant(d, "sht_reg_dct",SWIG_From_int((int)(sht_reg_dct)));
	3624	return SWIG_Py_Void();
	3625	}
	3626
	3627
	3628	SWIGINTERN PyObject sht_quick_init_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3629	PyObject *module;
	3630	PyObject *d;
	3631	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3632	d = PyModule_GetDict(module);
	3633	if (!d) return NULL;
	3634	SWIG_Python_SetConstant(d, "sht_quick_init",SWIG_From_int((int)(sht_quick_init)));
	3635	return SWIG_Py_Void();
	3636	}
	3637
	3638
	3639	SWIGINTERN PyObject sht_reg_poles_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3640	PyObject *module;
	3641	PyObject *d;
	3642	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3643	d = PyModule_GetDict(module);
	3644	if (!d) return NULL;
	3645	SWIG_Python_SetConstant(d, "sht_reg_poles",SWIG_From_int((int)(sht_reg_poles)));
	3646	return SWIG_Py_Void();
	3647	}
	3648
	3649
	3650	SWIGINTERN PyObject sht_gauss_fly_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3651	PyObject *module;
	3652	PyObject *d;
	3653	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3654	d = PyModule_GetDict(module);
	3655	if (!d) return NULL;
	3656	SWIG_Python_SetConstant(d, "sht_gauss_fly",SWIG_From_int((int)(sht_gauss_fly)));
	3657	return SWIG_Py_Void();
	3658	}
	3659
	3660
	3661	SWIGINTERN PyObject SHT_THETA_CONTIGUOUS_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3662	PyObject *module;
	3663	PyObject *d;
	3664	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3665	d = PyModule_GetDict(module);
	3666	if (!d) return NULL;
	3667	SWIG_Python_SetConstant(d, "SHT_THETA_CONTIGUOUS",SWIG_From_int((int)(256)));
	3668	return SWIG_Py_Void();
	3669	}
	3670
	3671
	3672	SWIGINTERN PyObject SHT_PHI_CONTIGUOUS_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3673	PyObject *module;
	3674	PyObject *d;
	3675	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3676	d = PyModule_GetDict(module);
	3677	if (!d) return NULL;
	3678	SWIG_Python_SetConstant(d, "SHT_PHI_CONTIGUOUS",SWIG_From_int((int)((256*2))));
	3679	return SWIG_Py_Void();
	3680	}
	3681
	3682
	3683	SWIGINTERN PyObject SHT_SOUTH_POLE_FIRST_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3684	PyObject *module;
	3685	PyObject *d;
	3686	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3687	d = PyModule_GetDict(module);
	3688	if (!d) return NULL;
	3689	SWIG_Python_SetConstant(d, "SHT_SOUTH_POLE_FIRST",SWIG_From_int((int)((256*32))));
	3690	return SWIG_Py_Void();
	3691	}
	3692
	3693
	3694	SWIGINTERN PyObject SHT_SCALAR_ONLY_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3695	PyObject *module;
	3696	PyObject *d;
	3697	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3698	d = PyModule_GetDict(module);
	3699	if (!d) return NULL;
	3700	SWIG_Python_SetConstant(d, "SHT_SCALAR_ONLY",SWIG_From_int((int)((256*16))));
	3701	return SWIG_Py_Void();
	3702	}
	3703
	3704
	3705	SWIGINTERN PyObject SHT_LOAD_SAVE_CFG_swigconstant(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3706	PyObject *module;
	3707	PyObject *d;
	3708	if (!PyArg_ParseTuple(args,(char*)"O:swigconstant", &module)) return NULL;
	3709	d = PyModule_GetDict(module);
	3710	if (!d) return NULL;
	3711	SWIG_Python_SetConstant(d, "SHT_LOAD_SAVE_CFG",SWIG_From_int((int)((256*64))));
	3712	return SWIG_Py_Void();
	3713	}
	3714
	3715
	3716	SWIGINTERN PyObject _wrap_sht_nlm_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3717	PyObject *resultobj = 0;
	3718	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3719	void *argp1 = 0 ;
	3720	int res1 = 0 ;
	3721	PyObject * obj0 = 0 ;
	3722	unsigned int result;
	3723
	3724	if (!PyArg_ParseTuple(args,(char *)"O:sht_nlm_get",&obj0)) SWIG_fail;
	3725	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3726	if (!SWIG_IsOK(res1)) {
	3727	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_nlm_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3728	}
	3729	arg1 = (struct shtns_info *)(argp1);
	3730	result = (unsigned int)(unsigned int) ((arg1)->nlm);
	3731	resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
	3732	return resultobj;
	3733	fail:
	3734	return NULL;
	3735	}
	3736
	3737
	3738	SWIGINTERN PyObject _wrap_sht_lmax_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3739	PyObject *resultobj = 0;
	3740	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3741	void *argp1 = 0 ;
	3742	int res1 = 0 ;
	3743	PyObject * obj0 = 0 ;
	3744	unsigned short result;
	3745
	3746	if (!PyArg_ParseTuple(args,(char *)"O:sht_lmax_get",&obj0)) SWIG_fail;
	3747	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3748	if (!SWIG_IsOK(res1)) {
	3749	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_lmax_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3750	}
	3751	arg1 = (struct shtns_info *)(argp1);
	3752	result = (unsigned short)(unsigned short) ((arg1)->lmax);
	3753	resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
	3754	return resultobj;
	3755	fail:
	3756	return NULL;
	3757	}
	3758
	3759
	3760	SWIGINTERN PyObject _wrap_sht_mmax_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3761	PyObject *resultobj = 0;
	3762	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3763	void *argp1 = 0 ;
	3764	int res1 = 0 ;
	3765	PyObject * obj0 = 0 ;
	3766	unsigned short result;
	3767
	3768	if (!PyArg_ParseTuple(args,(char *)"O:sht_mmax_get",&obj0)) SWIG_fail;
	3769	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3770	if (!SWIG_IsOK(res1)) {
	3771	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_mmax_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3772	}
	3773	arg1 = (struct shtns_info *)(argp1);
	3774	result = (unsigned short)(unsigned short) ((arg1)->mmax);
	3775	resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
	3776	return resultobj;
	3777	fail:
	3778	return NULL;
	3779	}
	3780
	3781
	3782	SWIGINTERN PyObject _wrap_sht_mres_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3783	PyObject *resultobj = 0;
	3784	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3785	void *argp1 = 0 ;
	3786	int res1 = 0 ;
	3787	PyObject * obj0 = 0 ;
	3788	unsigned short result;
	3789
	3790	if (!PyArg_ParseTuple(args,(char *)"O:sht_mres_get",&obj0)) SWIG_fail;
	3791	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3792	if (!SWIG_IsOK(res1)) {
	3793	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_mres_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3794	}
	3795	arg1 = (struct shtns_info *)(argp1);
	3796	result = (unsigned short)(unsigned short) ((arg1)->mres);
	3797	resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
	3798	return resultobj;
	3799	fail:
	3800	return NULL;
	3801	}
	3802
	3803
	3804	SWIGINTERN PyObject _wrap_sht_nphi_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3805	PyObject *resultobj = 0;
	3806	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3807	void *argp1 = 0 ;
	3808	int res1 = 0 ;
	3809	PyObject * obj0 = 0 ;
	3810	unsigned short result;
	3811
	3812	if (!PyArg_ParseTuple(args,(char *)"O:sht_nphi_get",&obj0)) SWIG_fail;
	3813	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3814	if (!SWIG_IsOK(res1)) {
	3815	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_nphi_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3816	}
	3817	arg1 = (struct shtns_info *)(argp1);
	3818	result = (unsigned short)(unsigned short) ((arg1)->nphi);
	3819	resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
	3820	return resultobj;
	3821	fail:
	3822	return NULL;
	3823	}
	3824
	3825
	3826	SWIGINTERN PyObject _wrap_sht_nlat_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3827	PyObject *resultobj = 0;
	3828	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3829	void *argp1 = 0 ;
	3830	int res1 = 0 ;
	3831	PyObject * obj0 = 0 ;
	3832	unsigned short result;
	3833
	3834	if (!PyArg_ParseTuple(args,(char *)"O:sht_nlat_get",&obj0)) SWIG_fail;
	3835	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3836	if (!SWIG_IsOK(res1)) {
	3837	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_nlat_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3838	}
	3839	arg1 = (struct shtns_info *)(argp1);
	3840	result = (unsigned short)(unsigned short) ((arg1)->nlat);
	3841	resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
	3842	return resultobj;
	3843	fail:
	3844	return NULL;
	3845	}
	3846
	3847
	3848	SWIGINTERN PyObject _wrap_sht_nspat_get(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3849	PyObject *resultobj = 0;
	3850	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3851	void *argp1 = 0 ;
	3852	int res1 = 0 ;
	3853	PyObject * obj0 = 0 ;
	3854	unsigned int result;
	3855
	3856	if (!PyArg_ParseTuple(args,(char *)"O:sht_nspat_get",&obj0)) SWIG_fail;
	3857	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	3858	if (!SWIG_IsOK(res1)) {
	3859	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_nspat_get" "', argument " "1"" of type '" "struct shtns_info *""'");
	3860	}
	3861	arg1 = (struct shtns_info *)(argp1);
	3862	result = (unsigned int)(unsigned int) ((arg1)->nspat);
	3863	resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
	3864	return resultobj;
	3865	fail:
	3866	return NULL;
	3867	}
	3868
	3869
	3870	SWIGINTERN PyObject _wrap_new_sht(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
	3871	PyObject *resultobj = 0;
	3872	int arg1 ;
	3873	int arg2 = (int) -1 ;
	3874	int arg3 = (int) 1 ;
	3875	int arg4 = (int) sht_orthonormal ;
	3876	int arg5 = (int) 0 ;
	3877	int val1 ;
	3878	int ecode1 = 0 ;
	3879	int val2 ;
	3880	int ecode2 = 0 ;
	3881	int val3 ;
	3882	int ecode3 = 0 ;
	3883	int val4 ;
	3884	int ecode4 = 0 ;
	3885	int val5 ;
	3886	int ecode5 = 0 ;
	3887	PyObject * obj0 = 0 ;
	3888	PyObject * obj1 = 0 ;
	3889	PyObject * obj2 = 0 ;
	3890	PyObject * obj3 = 0 ;
	3891	PyObject * obj4 = 0 ;
	3892	char * kwnames[] = {
	3893	(char ) "lmax",(char ) "mmax",(char ) "mres",(char ) "norm",(char *) "nthreads", NULL
	3894	};
	3895	struct shtns_info *result = 0 ;
	3896
	3897	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|OOOO:new_sht",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	3898	ecode1 = SWIG_AsVal_int(obj0, &val1);
	3899	if (!SWIG_IsOK(ecode1)) {
	3900	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_sht" "', argument " "1"" of type '" "int""'");
	3901	}
	3902	arg1 = (int)(val1);
	3903	if (obj1) {
	3904	ecode2 = SWIG_AsVal_int(obj1, &val2);
	3905	if (!SWIG_IsOK(ecode2)) {
	3906	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_sht" "', argument " "2"" of type '" "int""'");
	3907	}
	3908	arg2 = (int)(val2);
	3909	}
	3910	if (obj2) {
	3911	ecode3 = SWIG_AsVal_int(obj2, &val3);
	3912	if (!SWIG_IsOK(ecode3)) {
	3913	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_sht" "', argument " "3"" of type '" "int""'");
	3914	}
	3915	arg3 = (int)(val3);
	3916	}
	3917	if (obj3) {
	3918	ecode4 = SWIG_AsVal_int(obj3, &val4);
	3919	if (!SWIG_IsOK(ecode4)) {
	3920	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_sht" "', argument " "4"" of type '" "int""'");
	3921	}
	3922	arg4 = (int)(val4);
	3923	}
	3924	if (obj4) {
	3925	ecode5 = SWIG_AsVal_int(obj4, &val5);
	3926	if (!SWIG_IsOK(ecode5)) {
	3927	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_sht" "', argument " "5"" of type '" "int""'");
	3928	}
	3929	arg5 = (int)(val5);
	3930	}
	3931	{
	3932	shtns_error = 0; // clear exception
	3933	result = (struct shtns_info *)new_shtns_info(arg1,arg2,arg3,arg4,arg5);
	3934	if (shtns_error) {
	3935	// test for exception
	3936	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	3937	}
	3938	}
	3939	resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shtns_info, SWIG_POINTER_NEW \| 0 );
	3940	return resultobj;
	3941	fail:
	3942	return NULL;
	3943	}
	3944
	3945
	3946	SWIGINTERN PyObject _wrap_delete_sht(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	3947	PyObject *resultobj = 0;
	3948	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3949	void *argp1 = 0 ;
	3950	int res1 = 0 ;
	3951	PyObject * obj0 = 0 ;
	3952
	3953	if (!PyArg_ParseTuple(args,(char *)"O:delete_sht",&obj0)) SWIG_fail;
	3954	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, SWIG_POINTER_DISOWN \| 0 );
	3955	if (!SWIG_IsOK(res1)) {
	3956	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_sht" "', argument " "1"" of type '" "struct shtns_info *""'");
	3957	}
	3958	arg1 = (struct shtns_info *)(argp1);
	3959	{
	3960	shtns_error = 0; // clear exception
	3961	delete_shtns_info(arg1);
	3962	if (shtns_error) {
	3963	// test for exception
	3964	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	3965	}
	3966	}
	3967	resultobj = SWIG_Py_Void();
	3968	return resultobj;
	3969	fail:
	3970	return NULL;
	3971	}
	3972
	3973
	3974	SWIGINTERN PyObject _wrap_sht_set_grid(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
	3975	PyObject *resultobj = 0;
	3976	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	3977	int arg2 = (int) 0 ;
	3978	int arg3 = (int) 0 ;
	3979	int arg4 = (int) sht_quick_init ;
	3980	double arg5 = (double) 1.0e-8 ;
	3981	int arg6 = (int) 1 ;
	3982	int arg7 = (int ) 0 ;
	3983	int arg8 = (int ) 0 ;
	3984	void *argp1 = 0 ;
	3985	int res1 = 0 ;
	3986	int val2 ;
	3987	int ecode2 = 0 ;
	3988	int val3 ;
	3989	int ecode3 = 0 ;
	3990	int val4 ;
	3991	int ecode4 = 0 ;
	3992	double val5 ;
	3993	int ecode5 = 0 ;
	3994	int val6 ;
	3995	int ecode6 = 0 ;
	3996	int temp7 ;
	3997	int res7 = SWIG_TMPOBJ ;
	3998	int temp8 ;
	3999	int res8 = SWIG_TMPOBJ ;
	4000	PyObject * obj0 = 0 ;
	4001	PyObject * obj1 = 0 ;
	4002	PyObject * obj2 = 0 ;
	4003	PyObject * obj3 = 0 ;
	4004	PyObject * obj4 = 0 ;
	4005	PyObject * obj5 = 0 ;
	4006	char * kwnames[] = {
	4007	(char ) "self",(char ) "nlat",(char ) "nphi",(char ) "flags",(char ) "polar_opt",(char ) "nl_order", NULL
	4008	};
	4009
	4010	arg7 = &temp7;
	4011	arg8 = &temp8;
	4012	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|OOOOO:sht_set_grid",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	4013	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4014	if (!SWIG_IsOK(res1)) {
	4015	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_set_grid" "', argument " "1"" of type '" "struct shtns_info *""'");
	4016	}
	4017	arg1 = (struct shtns_info *)(argp1);
	4018	if (obj1) {
	4019	ecode2 = SWIG_AsVal_int(obj1, &val2);
	4020	if (!SWIG_IsOK(ecode2)) {
	4021	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sht_set_grid" "', argument " "2"" of type '" "int""'");
	4022	}
	4023	arg2 = (int)(val2);
	4024	}
	4025	if (obj2) {
	4026	ecode3 = SWIG_AsVal_int(obj2, &val3);
	4027	if (!SWIG_IsOK(ecode3)) {
	4028	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_set_grid" "', argument " "3"" of type '" "int""'");
	4029	}
	4030	arg3 = (int)(val3);
	4031	}
	4032	if (obj3) {
	4033	ecode4 = SWIG_AsVal_int(obj3, &val4);
	4034	if (!SWIG_IsOK(ecode4)) {
	4035	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sht_set_grid" "', argument " "4"" of type '" "int""'");
	4036	}
	4037	arg4 = (int)(val4);
	4038	}
	4039	if (obj4) {
	4040	ecode5 = SWIG_AsVal_double(obj4, &val5);
	4041	if (!SWIG_IsOK(ecode5)) {
	4042	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sht_set_grid" "', argument " "5"" of type '" "double""'");
	4043	}
	4044	arg5 = (double)(val5);
	4045	}
	4046	if (obj5) {
	4047	ecode6 = SWIG_AsVal_int(obj5, &val6);
	4048	if (!SWIG_IsOK(ecode6)) {
	4049	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "sht_set_grid" "', argument " "6"" of type '" "int""'");
	4050	}
	4051	arg6 = (int)(val6);
	4052	}
	4053	{
	4054	shtns_error = 0; // clear exception
	4055	shtns_info_set_grid(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
	4056	if (shtns_error) {
	4057	// test for exception
	4058	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4059	}
	4060	}
	4061	resultobj = SWIG_Py_Void();
	4062	if (SWIG_IsTmpObj(res7)) {
	4063	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg7)));
	4064	} else {
	4065	int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4066	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_int, new_flags));
	4067	}
	4068	if (SWIG_IsTmpObj(res8)) {
	4069	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg8)));
	4070	} else {
	4071	int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4072	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_int, new_flags));
	4073	}
	4074	return resultobj;
	4075	fail:
	4076	return NULL;
	4077	}
	4078
	4079
	4080	SWIGINTERN PyObject _wrap_sht_print_info(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4081	PyObject *resultobj = 0;
	4082	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4083	void *argp1 = 0 ;
	4084	int res1 = 0 ;
	4085	PyObject * obj0 = 0 ;
	4086
	4087	if (!PyArg_ParseTuple(args,(char *)"O:sht_print_info",&obj0)) SWIG_fail;
	4088	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4089	if (!SWIG_IsOK(res1)) {
	4090	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_print_info" "', argument " "1"" of type '" "struct shtns_info *""'");
	4091	}
	4092	arg1 = (struct shtns_info *)(argp1);
	4093	{
	4094	shtns_error = 0; // clear exception
	4095	shtns_info_print_info(arg1);
	4096	if (shtns_error) {
	4097	// test for exception
	4098	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4099	}
	4100	}
	4101	resultobj = SWIG_Py_Void();
	4102	return resultobj;
	4103	fail:
	4104	return NULL;
	4105	}
	4106
	4107
	4108	SWIGINTERN PyObject _wrap_sht_sh00_1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4109	PyObject *resultobj = 0;
	4110	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4111	void *argp1 = 0 ;
	4112	int res1 = 0 ;
	4113	PyObject * obj0 = 0 ;
	4114	double result;
	4115
	4116	if (!PyArg_ParseTuple(args,(char *)"O:sht_sh00_1",&obj0)) SWIG_fail;
	4117	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4118	if (!SWIG_IsOK(res1)) {
	4119	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_sh00_1" "', argument " "1"" of type '" "struct shtns_info *""'");
	4120	}
	4121	arg1 = (struct shtns_info *)(argp1);
	4122	{
	4123	shtns_error = 0; // clear exception
	4124	result = (double)shtns_info_sh00_1(arg1);
	4125	if (shtns_error) {
	4126	// test for exception
	4127	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4128	}
	4129	}
	4130	resultobj = SWIG_From_double((double)(result));
	4131	return resultobj;
	4132	fail:
	4133	return NULL;
	4134	}
	4135
	4136
	4137	SWIGINTERN PyObject _wrap_sht_sh10_ct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4138	PyObject *resultobj = 0;
	4139	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4140	void *argp1 = 0 ;
	4141	int res1 = 0 ;
	4142	PyObject * obj0 = 0 ;
	4143	double result;
	4144
	4145	if (!PyArg_ParseTuple(args,(char *)"O:sht_sh10_ct",&obj0)) SWIG_fail;
	4146	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4147	if (!SWIG_IsOK(res1)) {
	4148	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_sh10_ct" "', argument " "1"" of type '" "struct shtns_info *""'");
	4149	}
	4150	arg1 = (struct shtns_info *)(argp1);
	4151	{
	4152	shtns_error = 0; // clear exception
	4153	result = (double)shtns_info_sh10_ct(arg1);
	4154	if (shtns_error) {
	4155	// test for exception
	4156	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4157	}
	4158	}
	4159	resultobj = SWIG_From_double((double)(result));
	4160	return resultobj;
	4161	fail:
	4162	return NULL;
	4163	}
	4164
	4165
	4166	SWIGINTERN PyObject _wrap_sht_sh11_st(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4167	PyObject *resultobj = 0;
	4168	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4169	void *argp1 = 0 ;
	4170	int res1 = 0 ;
	4171	PyObject * obj0 = 0 ;
	4172	double result;
	4173
	4174	if (!PyArg_ParseTuple(args,(char *)"O:sht_sh11_st",&obj0)) SWIG_fail;
	4175	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4176	if (!SWIG_IsOK(res1)) {
	4177	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_sh11_st" "', argument " "1"" of type '" "struct shtns_info *""'");
	4178	}
	4179	arg1 = (struct shtns_info *)(argp1);
	4180	{
	4181	shtns_error = 0; // clear exception
	4182	result = (double)shtns_info_sh11_st(arg1);
	4183	if (shtns_error) {
	4184	// test for exception
	4185	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4186	}
	4187	}
	4188	resultobj = SWIG_From_double((double)(result));
	4189	return resultobj;
	4190	fail:
	4191	return NULL;
	4192	}
	4193
	4194
	4195	SWIGINTERN PyObject _wrap_sht_shlm_e1(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4196	PyObject *resultobj = 0;
	4197	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4198	unsigned int arg2 ;
	4199	unsigned int arg3 ;
	4200	void *argp1 = 0 ;
	4201	int res1 = 0 ;
	4202	unsigned int val2 ;
	4203	int ecode2 = 0 ;
	4204	unsigned int val3 ;
	4205	int ecode3 = 0 ;
	4206	PyObject * obj0 = 0 ;
	4207	PyObject * obj1 = 0 ;
	4208	PyObject * obj2 = 0 ;
	4209	double result;
	4210
	4211	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_shlm_e1",&obj0,&obj1,&obj2)) SWIG_fail;
	4212	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4213	if (!SWIG_IsOK(res1)) {
	4214	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_shlm_e1" "', argument " "1"" of type '" "struct shtns_info *""'");
	4215	}
	4216	arg1 = (struct shtns_info *)(argp1);
	4217	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	4218	if (!SWIG_IsOK(ecode2)) {
	4219	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sht_shlm_e1" "', argument " "2"" of type '" "unsigned int""'");
	4220	}
	4221	arg2 = (unsigned int)(val2);
	4222	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	4223	if (!SWIG_IsOK(ecode3)) {
	4224	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_shlm_e1" "', argument " "3"" of type '" "unsigned int""'");
	4225	}
	4226	arg3 = (unsigned int)(val3);
	4227	{
	4228	shtns_error = 0; // clear exception
	4229	result = (double)shtns_info_shlm_e1(arg1,arg2,arg3);
	4230	if (shtns_error) {
	4231	// test for exception
	4232	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4233	}
	4234	}
	4235	resultobj = SWIG_From_double((double)(result));
	4236	return resultobj;
	4237	fail:
	4238	return NULL;
	4239	}
	4240
	4241
	4242	SWIGINTERN PyObject _wrap_sht___ct(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4243	PyObject *resultobj = 0;
	4244	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4245	void *argp1 = 0 ;
	4246	int res1 = 0 ;
	4247	PyObject * obj0 = 0 ;
	4248	PyObject *result = 0 ;
	4249
	4250	if (!PyArg_ParseTuple(args,(char *)"O:sht___ct",&obj0)) SWIG_fail;
	4251	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4252	if (!SWIG_IsOK(res1)) {
	4253	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht___ct" "', argument " "1"" of type '" "struct shtns_info *""'");
	4254	}
	4255	arg1 = (struct shtns_info *)(argp1);
	4256	{
	4257	shtns_error = 0; // clear exception
	4258	result = (PyObject *)shtns_info___ct(arg1);
	4259	if (shtns_error) {
	4260	// test for exception
	4261	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4262	}
	4263	}
	4264	resultobj = result;
	4265	return resultobj;
	4266	fail:
	4267	return NULL;
	4268	}
	4269
	4270
	4271	SWIGINTERN PyObject _wrap_sht_gauss_wts(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4272	PyObject *resultobj = 0;
	4273	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4274	void *argp1 = 0 ;
	4275	int res1 = 0 ;
	4276	PyObject * obj0 = 0 ;
	4277	PyObject *result = 0 ;
	4278
	4279	if (!PyArg_ParseTuple(args,(char *)"O:sht_gauss_wts",&obj0)) SWIG_fail;
	4280	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4281	if (!SWIG_IsOK(res1)) {
	4282	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_gauss_wts" "', argument " "1"" of type '" "struct shtns_info *""'");
	4283	}
	4284	arg1 = (struct shtns_info *)(argp1);
	4285	{
	4286	shtns_error = 0; // clear exception
	4287	result = (PyObject *)shtns_info_gauss_wts(arg1);
	4288	if (shtns_error) {
	4289	// test for exception
	4290	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4291	}
	4292	}
	4293	resultobj = result;
	4294	return resultobj;
	4295	fail:
	4296	return NULL;
	4297	}
	4298
	4299
	4300	SWIGINTERN PyObject _wrap_sht_mul_ct_matrix(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4301	PyObject *resultobj = 0;
	4302	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4303	void *argp1 = 0 ;
	4304	int res1 = 0 ;
	4305	PyObject * obj0 = 0 ;
	4306	PyObject *result = 0 ;
	4307
	4308	if (!PyArg_ParseTuple(args,(char *)"O:sht_mul_ct_matrix",&obj0)) SWIG_fail;
	4309	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4310	if (!SWIG_IsOK(res1)) {
	4311	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_mul_ct_matrix" "', argument " "1"" of type '" "struct shtns_info *""'");
	4312	}
	4313	arg1 = (struct shtns_info *)(argp1);
	4314	{
	4315	shtns_error = 0; // clear exception
	4316	result = (PyObject *)shtns_info_mul_ct_matrix(arg1);
	4317	if (shtns_error) {
	4318	// test for exception
	4319	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4320	}
	4321	}
	4322	resultobj = result;
	4323	return resultobj;
	4324	fail:
	4325	return NULL;
	4326	}
	4327
	4328
	4329	SWIGINTERN PyObject _wrap_sht_st_dt_matrix(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4330	PyObject *resultobj = 0;
	4331	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4332	void *argp1 = 0 ;
	4333	int res1 = 0 ;
	4334	PyObject * obj0 = 0 ;
	4335	PyObject *result = 0 ;
	4336
	4337	if (!PyArg_ParseTuple(args,(char *)"O:sht_st_dt_matrix",&obj0)) SWIG_fail;
	4338	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4339	if (!SWIG_IsOK(res1)) {
	4340	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_st_dt_matrix" "', argument " "1"" of type '" "struct shtns_info *""'");
	4341	}
	4342	arg1 = (struct shtns_info *)(argp1);
	4343	{
	4344	shtns_error = 0; // clear exception
	4345	result = (PyObject *)shtns_info_st_dt_matrix(arg1);
	4346	if (shtns_error) {
	4347	// test for exception
	4348	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4349	}
	4350	}
	4351	resultobj = result;
	4352	return resultobj;
	4353	fail:
	4354	return NULL;
	4355	}
	4356
	4357
	4358	SWIGINTERN PyObject _wrap_sht___spat_shape(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4359	PyObject *resultobj = 0;
	4360	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4361	int arg2 = (int ) 0 ;
	4362	int arg3 = (int ) 0 ;
	4363	void *argp1 = 0 ;
	4364	int res1 = 0 ;
	4365	int temp2 ;
	4366	int res2 = SWIG_TMPOBJ ;
	4367	int temp3 ;
	4368	int res3 = SWIG_TMPOBJ ;
	4369	PyObject * obj0 = 0 ;
	4370
	4371	arg2 = &temp2;
	4372	arg3 = &temp3;
	4373	if (!PyArg_ParseTuple(args,(char *)"O:sht___spat_shape",&obj0)) SWIG_fail;
	4374	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4375	if (!SWIG_IsOK(res1)) {
	4376	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht___spat_shape" "', argument " "1"" of type '" "struct shtns_info *""'");
	4377	}
	4378	arg1 = (struct shtns_info *)(argp1);
	4379	{
	4380	shtns_error = 0; // clear exception
	4381	shtns_info___spat_shape(arg1,arg2,arg3);
	4382	if (shtns_error) {
	4383	// test for exception
	4384	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4385	}
	4386	}
	4387	resultobj = SWIG_Py_Void();
	4388	if (SWIG_IsTmpObj(res2)) {
	4389	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
	4390	} else {
	4391	int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4392	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
	4393	}
	4394	if (SWIG_IsTmpObj(res3)) {
	4395	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
	4396	} else {
	4397	int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4398	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
	4399	}
	4400	return resultobj;
	4401	fail:
	4402	return NULL;
	4403	}
	4404
	4405
	4406	SWIGINTERN PyObject _wrap_sht_idx(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4407	PyObject *resultobj = 0;
	4408	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4409	unsigned int arg2 ;
	4410	unsigned int arg3 ;
	4411	void *argp1 = 0 ;
	4412	int res1 = 0 ;
	4413	unsigned int val2 ;
	4414	int ecode2 = 0 ;
	4415	unsigned int val3 ;
	4416	int ecode3 = 0 ;
	4417	PyObject * obj0 = 0 ;
	4418	PyObject * obj1 = 0 ;
	4419	PyObject * obj2 = 0 ;
	4420	int result;
	4421
	4422	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_idx",&obj0,&obj1,&obj2)) SWIG_fail;
	4423	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4424	if (!SWIG_IsOK(res1)) {
	4425	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_idx" "', argument " "1"" of type '" "struct shtns_info *""'");
	4426	}
	4427	arg1 = (struct shtns_info *)(argp1);
	4428	ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
	4429	if (!SWIG_IsOK(ecode2)) {
	4430	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sht_idx" "', argument " "2"" of type '" "unsigned int""'");
	4431	}
	4432	arg2 = (unsigned int)(val2);
	4433	ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
	4434	if (!SWIG_IsOK(ecode3)) {
	4435	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_idx" "', argument " "3"" of type '" "unsigned int""'");
	4436	}
	4437	arg3 = (unsigned int)(val3);
	4438	{
	4439	shtns_error = 0; // clear exception
	4440	result = (int)shtns_info_idx(arg1,arg2,arg3);
	4441	if (shtns_error) {
	4442	// test for exception
	4443	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4444	}
	4445	}
	4446	resultobj = SWIG_From_int((int)(result));
	4447	return resultobj;
	4448	fail:
	4449	return NULL;
	4450	}
	4451
	4452
	4453	SWIGINTERN PyObject _wrap_sht_spat_to_SH(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4454	PyObject *resultobj = 0;
	4455	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4456	PyObject arg2 = (PyObject ) 0 ;
	4457	PyObject arg3 = (PyObject ) 0 ;
	4458	void *argp1 = 0 ;
	4459	int res1 = 0 ;
	4460	PyObject * obj0 = 0 ;
	4461	PyObject * obj1 = 0 ;
	4462	PyObject * obj2 = 0 ;
	4463
	4464	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_spat_to_SH",&obj0,&obj1,&obj2)) SWIG_fail;
	4465	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4466	if (!SWIG_IsOK(res1)) {
	4467	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SH" "', argument " "1"" of type '" "struct shtns_info *""'");
	4468	}
	4469	arg1 = (struct shtns_info *)(argp1);
	4470	arg2 = obj1;
	4471	arg3 = obj2;
	4472	{
	4473	shtns_error = 0; // clear exception
	4474	shtns_info_spat_to_SH(arg1,arg2,arg3);
	4475	if (shtns_error) {
	4476	// test for exception
	4477	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4478	}
	4479	}
	4480	resultobj = SWIG_Py_Void();
	4481	return resultobj;
	4482	fail:
	4483	return NULL;
	4484	}
	4485
	4486
	4487	SWIGINTERN PyObject _wrap_sht_SH_to_spat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4488	PyObject *resultobj = 0;
	4489	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4490	PyObject arg2 = (PyObject ) 0 ;
	4491	PyObject arg3 = (PyObject ) 0 ;
	4492	void *argp1 = 0 ;
	4493	int res1 = 0 ;
	4494	PyObject * obj0 = 0 ;
	4495	PyObject * obj1 = 0 ;
	4496	PyObject * obj2 = 0 ;
	4497
	4498	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_SH_to_spat",&obj0,&obj1,&obj2)) SWIG_fail;
	4499	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4500	if (!SWIG_IsOK(res1)) {
	4501	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_to_spat" "', argument " "1"" of type '" "struct shtns_info *""'");
	4502	}
	4503	arg1 = (struct shtns_info *)(argp1);
	4504	arg2 = obj1;
	4505	arg3 = obj2;
	4506	{
	4507	shtns_error = 0; // clear exception
	4508	shtns_info_SH_to_spat(arg1,arg2,arg3);
	4509	if (shtns_error) {
	4510	// test for exception
	4511	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4512	}
	4513	}
	4514	resultobj = SWIG_Py_Void();
	4515	return resultobj;
	4516	fail:
	4517	return NULL;
	4518	}
	4519
	4520
	4521	SWIGINTERN PyObject _wrap_sht_spat_cplx_to_SH(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4522	PyObject *resultobj = 0;
	4523	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4524	PyObject arg2 = (PyObject ) 0 ;
	4525	PyObject arg3 = (PyObject ) 0 ;
	4526	void *argp1 = 0 ;
	4527	int res1 = 0 ;
	4528	PyObject * obj0 = 0 ;
	4529	PyObject * obj1 = 0 ;
	4530	PyObject * obj2 = 0 ;
	4531
	4532	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_spat_cplx_to_SH",&obj0,&obj1,&obj2)) SWIG_fail;
	4533	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4534	if (!SWIG_IsOK(res1)) {
	4535	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_cplx_to_SH" "', argument " "1"" of type '" "struct shtns_info *""'");
	4536	}
	4537	arg1 = (struct shtns_info *)(argp1);
	4538	arg2 = obj1;
	4539	arg3 = obj2;
	4540	{
	4541	shtns_error = 0; // clear exception
	4542	shtns_info_spat_cplx_to_SH(arg1,arg2,arg3);
	4543	if (shtns_error) {
	4544	// test for exception
	4545	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4546	}
	4547	}
	4548	resultobj = SWIG_Py_Void();
	4549	return resultobj;
	4550	fail:
	4551	return NULL;
	4552	}
	4553
	4554
	4555	SWIGINTERN PyObject _wrap_sht_SH_to_spat_cplx(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4556	PyObject *resultobj = 0;
	4557	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4558	PyObject arg2 = (PyObject ) 0 ;
	4559	PyObject arg3 = (PyObject ) 0 ;
	4560	void *argp1 = 0 ;
	4561	int res1 = 0 ;
	4562	PyObject * obj0 = 0 ;
	4563	PyObject * obj1 = 0 ;
	4564	PyObject * obj2 = 0 ;
	4565
	4566	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_SH_to_spat_cplx",&obj0,&obj1,&obj2)) SWIG_fail;
	4567	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4568	if (!SWIG_IsOK(res1)) {
	4569	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_to_spat_cplx" "', argument " "1"" of type '" "struct shtns_info *""'");
	4570	}
	4571	arg1 = (struct shtns_info *)(argp1);
	4572	arg2 = obj1;
	4573	arg3 = obj2;
	4574	{
	4575	shtns_error = 0; // clear exception
	4576	shtns_info_SH_to_spat_cplx(arg1,arg2,arg3);
	4577	if (shtns_error) {
	4578	// test for exception
	4579	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4580	}
	4581	}
	4582	resultobj = SWIG_Py_Void();
	4583	return resultobj;
	4584	fail:
	4585	return NULL;
	4586	}
	4587
	4588
	4589	SWIGINTERN PyObject _wrap_sht_spat_to_SHsphtor(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4590	PyObject *resultobj = 0;
	4591	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4592	PyObject arg2 = (PyObject ) 0 ;
	4593	PyObject arg3 = (PyObject ) 0 ;
	4594	PyObject arg4 = (PyObject ) 0 ;
	4595	PyObject arg5 = (PyObject ) 0 ;
	4596	void *argp1 = 0 ;
	4597	int res1 = 0 ;
	4598	PyObject * obj0 = 0 ;
	4599	PyObject * obj1 = 0 ;
	4600	PyObject * obj2 = 0 ;
	4601	PyObject * obj3 = 0 ;
	4602	PyObject * obj4 = 0 ;
	4603
	4604	if (!PyArg_ParseTuple(args,(char *)"OOOOO:sht_spat_to_SHsphtor",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	4605	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4606	if (!SWIG_IsOK(res1)) {
	4607	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SHsphtor" "', argument " "1"" of type '" "struct shtns_info *""'");
	4608	}
	4609	arg1 = (struct shtns_info *)(argp1);
	4610	arg2 = obj1;
	4611	arg3 = obj2;
	4612	arg4 = obj3;
	4613	arg5 = obj4;
	4614	{
	4615	shtns_error = 0; // clear exception
	4616	shtns_info_spat_to_SHsphtor(arg1,arg2,arg3,arg4,arg5);
	4617	if (shtns_error) {
	4618	// test for exception
	4619	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4620	}
	4621	}
	4622	resultobj = SWIG_Py_Void();
	4623	return resultobj;
	4624	fail:
	4625	return NULL;
	4626	}
	4627
	4628
	4629	SWIGINTERN PyObject _wrap_sht_SHsphtor_to_spat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4630	PyObject *resultobj = 0;
	4631	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4632	PyObject arg2 = (PyObject ) 0 ;
	4633	PyObject arg3 = (PyObject ) 0 ;
	4634	PyObject arg4 = (PyObject ) 0 ;
	4635	PyObject arg5 = (PyObject ) 0 ;
	4636	void *argp1 = 0 ;
	4637	int res1 = 0 ;
	4638	PyObject * obj0 = 0 ;
	4639	PyObject * obj1 = 0 ;
	4640	PyObject * obj2 = 0 ;
	4641	PyObject * obj3 = 0 ;
	4642	PyObject * obj4 = 0 ;
	4643
	4644	if (!PyArg_ParseTuple(args,(char *)"OOOOO:sht_SHsphtor_to_spat",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	4645	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4646	if (!SWIG_IsOK(res1)) {
	4647	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHsphtor_to_spat" "', argument " "1"" of type '" "struct shtns_info *""'");
	4648	}
	4649	arg1 = (struct shtns_info *)(argp1);
	4650	arg2 = obj1;
	4651	arg3 = obj2;
	4652	arg4 = obj3;
	4653	arg5 = obj4;
	4654	{
	4655	shtns_error = 0; // clear exception
	4656	shtns_info_SHsphtor_to_spat(arg1,arg2,arg3,arg4,arg5);
	4657	if (shtns_error) {
	4658	// test for exception
	4659	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4660	}
	4661	}
	4662	resultobj = SWIG_Py_Void();
	4663	return resultobj;
	4664	fail:
	4665	return NULL;
	4666	}
	4667
	4668
	4669	SWIGINTERN PyObject _wrap_sht_SHsph_to_spat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4670	PyObject *resultobj = 0;
	4671	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4672	PyObject arg2 = (PyObject ) 0 ;
	4673	PyObject arg3 = (PyObject ) 0 ;
	4674	PyObject arg4 = (PyObject ) 0 ;
	4675	void *argp1 = 0 ;
	4676	int res1 = 0 ;
	4677	PyObject * obj0 = 0 ;
	4678	PyObject * obj1 = 0 ;
	4679	PyObject * obj2 = 0 ;
	4680	PyObject * obj3 = 0 ;
	4681
	4682	if (!PyArg_ParseTuple(args,(char *)"OOOO:sht_SHsph_to_spat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	4683	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4684	if (!SWIG_IsOK(res1)) {
	4685	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHsph_to_spat" "', argument " "1"" of type '" "struct shtns_info *""'");
	4686	}
	4687	arg1 = (struct shtns_info *)(argp1);
	4688	arg2 = obj1;
	4689	arg3 = obj2;
	4690	arg4 = obj3;
	4691	{
	4692	shtns_error = 0; // clear exception
	4693	shtns_info_SHsph_to_spat(arg1,arg2,arg3,arg4);
	4694	if (shtns_error) {
	4695	// test for exception
	4696	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4697	}
	4698	}
	4699	resultobj = SWIG_Py_Void();
	4700	return resultobj;
	4701	fail:
	4702	return NULL;
	4703	}
	4704
	4705
	4706	SWIGINTERN PyObject _wrap_sht_SHtor_to_spat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4707	PyObject *resultobj = 0;
	4708	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4709	PyObject arg2 = (PyObject ) 0 ;
	4710	PyObject arg3 = (PyObject ) 0 ;
	4711	PyObject arg4 = (PyObject ) 0 ;
	4712	void *argp1 = 0 ;
	4713	int res1 = 0 ;
	4714	PyObject * obj0 = 0 ;
	4715	PyObject * obj1 = 0 ;
	4716	PyObject * obj2 = 0 ;
	4717	PyObject * obj3 = 0 ;
	4718
	4719	if (!PyArg_ParseTuple(args,(char *)"OOOO:sht_SHtor_to_spat",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	4720	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4721	if (!SWIG_IsOK(res1)) {
	4722	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHtor_to_spat" "', argument " "1"" of type '" "struct shtns_info *""'");
	4723	}
	4724	arg1 = (struct shtns_info *)(argp1);
	4725	arg2 = obj1;
	4726	arg3 = obj2;
	4727	arg4 = obj3;
	4728	{
	4729	shtns_error = 0; // clear exception
	4730	shtns_info_SHtor_to_spat(arg1,arg2,arg3,arg4);
	4731	if (shtns_error) {
	4732	// test for exception
	4733	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4734	}
	4735	}
	4736	resultobj = SWIG_Py_Void();
	4737	return resultobj;
	4738	fail:
	4739	return NULL;
	4740	}
	4741
	4742
	4743	SWIGINTERN PyObject _wrap_sht_spat_to_SHqst(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4744	PyObject *resultobj = 0;
	4745	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4746	PyObject arg2 = (PyObject ) 0 ;
	4747	PyObject arg3 = (PyObject ) 0 ;
	4748	PyObject arg4 = (PyObject ) 0 ;
	4749	PyObject arg5 = (PyObject ) 0 ;
	4750	PyObject arg6 = (PyObject ) 0 ;
	4751	PyObject arg7 = (PyObject ) 0 ;
	4752	void *argp1 = 0 ;
	4753	int res1 = 0 ;
	4754	PyObject * obj0 = 0 ;
	4755	PyObject * obj1 = 0 ;
	4756	PyObject * obj2 = 0 ;
	4757	PyObject * obj3 = 0 ;
	4758	PyObject * obj4 = 0 ;
	4759	PyObject * obj5 = 0 ;
	4760	PyObject * obj6 = 0 ;
	4761
	4762	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:sht_spat_to_SHqst",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	4763	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4764	if (!SWIG_IsOK(res1)) {
	4765	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SHqst" "', argument " "1"" of type '" "struct shtns_info *""'");
	4766	}
	4767	arg1 = (struct shtns_info *)(argp1);
	4768	arg2 = obj1;
	4769	arg3 = obj2;
	4770	arg4 = obj3;
	4771	arg5 = obj4;
	4772	arg6 = obj5;
	4773	arg7 = obj6;
	4774	{
	4775	shtns_error = 0; // clear exception
	4776	shtns_info_spat_to_SHqst(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
	4777	if (shtns_error) {
	4778	// test for exception
	4779	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4780	}
	4781	}
	4782	resultobj = SWIG_Py_Void();
	4783	return resultobj;
	4784	fail:
	4785	return NULL;
	4786	}
	4787
	4788
	4789	SWIGINTERN PyObject _wrap_sht_SHqst_to_spat(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4790	PyObject *resultobj = 0;
	4791	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4792	PyObject arg2 = (PyObject ) 0 ;
	4793	PyObject arg3 = (PyObject ) 0 ;
	4794	PyObject arg4 = (PyObject ) 0 ;
	4795	PyObject arg5 = (PyObject ) 0 ;
	4796	PyObject arg6 = (PyObject ) 0 ;
	4797	PyObject arg7 = (PyObject ) 0 ;
	4798	void *argp1 = 0 ;
	4799	int res1 = 0 ;
	4800	PyObject * obj0 = 0 ;
	4801	PyObject * obj1 = 0 ;
	4802	PyObject * obj2 = 0 ;
	4803	PyObject * obj3 = 0 ;
	4804	PyObject * obj4 = 0 ;
	4805	PyObject * obj5 = 0 ;
	4806	PyObject * obj6 = 0 ;
	4807
	4808	if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:sht_SHqst_to_spat",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
	4809	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4810	if (!SWIG_IsOK(res1)) {
	4811	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHqst_to_spat" "', argument " "1"" of type '" "struct shtns_info *""'");
	4812	}
	4813	arg1 = (struct shtns_info *)(argp1);
	4814	arg2 = obj1;
	4815	arg3 = obj2;
	4816	arg4 = obj3;
	4817	arg5 = obj4;
	4818	arg6 = obj5;
	4819	arg7 = obj6;
	4820	{
	4821	shtns_error = 0; // clear exception
	4822	shtns_info_SHqst_to_spat(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
	4823	if (shtns_error) {
	4824	// test for exception
	4825	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4826	}
	4827	}
	4828	resultobj = SWIG_Py_Void();
	4829	return resultobj;
	4830	fail:
	4831	return NULL;
	4832	}
	4833
	4834
	4835	SWIGINTERN PyObject _wrap_sht_SH_to_point(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4836	PyObject *resultobj = 0;
	4837	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4838	PyObject arg2 = (PyObject ) 0 ;
	4839	double arg3 ;
	4840	double arg4 ;
	4841	void *argp1 = 0 ;
	4842	int res1 = 0 ;
	4843	double val3 ;
	4844	int ecode3 = 0 ;
	4845	double val4 ;
	4846	int ecode4 = 0 ;
	4847	PyObject * obj0 = 0 ;
	4848	PyObject * obj1 = 0 ;
	4849	PyObject * obj2 = 0 ;
	4850	PyObject * obj3 = 0 ;
	4851	double result;
	4852
	4853	if (!PyArg_ParseTuple(args,(char *)"OOOO:sht_SH_to_point",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	4854	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4855	if (!SWIG_IsOK(res1)) {
	4856	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_to_point" "', argument " "1"" of type '" "struct shtns_info *""'");
	4857	}
	4858	arg1 = (struct shtns_info *)(argp1);
	4859	arg2 = obj1;
	4860	ecode3 = SWIG_AsVal_double(obj2, &val3);
	4861	if (!SWIG_IsOK(ecode3)) {
	4862	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_SH_to_point" "', argument " "3"" of type '" "double""'");
	4863	}
	4864	arg3 = (double)(val3);
	4865	ecode4 = SWIG_AsVal_double(obj3, &val4);
	4866	if (!SWIG_IsOK(ecode4)) {
	4867	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sht_SH_to_point" "', argument " "4"" of type '" "double""'");
	4868	}
	4869	arg4 = (double)(val4);
	4870	{
	4871	shtns_error = 0; // clear exception
	4872	result = (double)shtns_info_SH_to_point(arg1,arg2,arg3,arg4);
	4873	if (shtns_error) {
	4874	// test for exception
	4875	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4876	}
	4877	}
	4878	resultobj = SWIG_From_double((double)(result));
	4879	return resultobj;
	4880	fail:
	4881	return NULL;
	4882	}
	4883
	4884
	4885	SWIGINTERN PyObject _wrap_sht_SH_to_grad_point(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4886	PyObject *resultobj = 0;
	4887	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4888	PyObject arg2 = (PyObject ) 0 ;
	4889	PyObject arg3 = (PyObject ) 0 ;
	4890	double arg4 ;
	4891	double arg5 ;
	4892	double arg6 = (double ) 0 ;
	4893	double arg7 = (double ) 0 ;
	4894	double arg8 = (double ) 0 ;
	4895	void *argp1 = 0 ;
	4896	int res1 = 0 ;
	4897	double val4 ;
	4898	int ecode4 = 0 ;
	4899	double val5 ;
	4900	int ecode5 = 0 ;
	4901	double temp6 ;
	4902	int res6 = SWIG_TMPOBJ ;
	4903	double temp7 ;
	4904	int res7 = SWIG_TMPOBJ ;
	4905	double temp8 ;
	4906	int res8 = SWIG_TMPOBJ ;
	4907	PyObject * obj0 = 0 ;
	4908	PyObject * obj1 = 0 ;
	4909	PyObject * obj2 = 0 ;
	4910	PyObject * obj3 = 0 ;
	4911	PyObject * obj4 = 0 ;
	4912
	4913	arg6 = &temp6;
	4914	arg7 = &temp7;
	4915	arg8 = &temp8;
	4916	if (!PyArg_ParseTuple(args,(char *)"OOOOO:sht_SH_to_grad_point",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	4917	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	4918	if (!SWIG_IsOK(res1)) {
	4919	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_to_grad_point" "', argument " "1"" of type '" "struct shtns_info *""'");
	4920	}
	4921	arg1 = (struct shtns_info *)(argp1);
	4922	arg2 = obj1;
	4923	arg3 = obj2;
	4924	ecode4 = SWIG_AsVal_double(obj3, &val4);
	4925	if (!SWIG_IsOK(ecode4)) {
	4926	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sht_SH_to_grad_point" "', argument " "4"" of type '" "double""'");
	4927	}
	4928	arg4 = (double)(val4);
	4929	ecode5 = SWIG_AsVal_double(obj4, &val5);
	4930	if (!SWIG_IsOK(ecode5)) {
	4931	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sht_SH_to_grad_point" "', argument " "5"" of type '" "double""'");
	4932	}
	4933	arg5 = (double)(val5);
	4934	{
	4935	shtns_error = 0; // clear exception
	4936	shtns_info_SH_to_grad_point(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
	4937	if (shtns_error) {
	4938	// test for exception
	4939	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	4940	}
	4941	}
	4942	resultobj = SWIG_Py_Void();
	4943	if (SWIG_IsTmpObj(res6)) {
	4944	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg6)));
	4945	} else {
	4946	int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4947	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_double, new_flags));
	4948	}
	4949	if (SWIG_IsTmpObj(res7)) {
	4950	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
	4951	} else {
	4952	int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4953	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
	4954	}
	4955	if (SWIG_IsTmpObj(res8)) {
	4956	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
	4957	} else {
	4958	int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	4959	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
	4960	}
	4961	return resultobj;
	4962	fail:
	4963	return NULL;
	4964	}
	4965
	4966
	4967	SWIGINTERN PyObject _wrap_sht_SHqst_to_point(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	4968	PyObject *resultobj = 0;
	4969	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	4970	PyObject arg2 = (PyObject ) 0 ;
	4971	PyObject arg3 = (PyObject ) 0 ;
	4972	PyObject arg4 = (PyObject ) 0 ;
	4973	double arg5 ;
	4974	double arg6 ;
	4975	double arg7 = (double ) 0 ;
	4976	double arg8 = (double ) 0 ;
	4977	double arg9 = (double ) 0 ;
	4978	void *argp1 = 0 ;
	4979	int res1 = 0 ;
	4980	double val5 ;
	4981	int ecode5 = 0 ;
	4982	double val6 ;
	4983	int ecode6 = 0 ;
	4984	double temp7 ;
	4985	int res7 = SWIG_TMPOBJ ;
	4986	double temp8 ;
	4987	int res8 = SWIG_TMPOBJ ;
	4988	double temp9 ;
	4989	int res9 = SWIG_TMPOBJ ;
	4990	PyObject * obj0 = 0 ;
	4991	PyObject * obj1 = 0 ;
	4992	PyObject * obj2 = 0 ;
	4993	PyObject * obj3 = 0 ;
	4994	PyObject * obj4 = 0 ;
	4995	PyObject * obj5 = 0 ;
	4996
	4997	arg7 = &temp7;
	4998	arg8 = &temp8;
	4999	arg9 = &temp9;
	5000	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:sht_SHqst_to_point",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	5001	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5002	if (!SWIG_IsOK(res1)) {
	5003	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHqst_to_point" "', argument " "1"" of type '" "struct shtns_info *""'");
	5004	}
	5005	arg1 = (struct shtns_info *)(argp1);
	5006	arg2 = obj1;
	5007	arg3 = obj2;
	5008	arg4 = obj3;
	5009	ecode5 = SWIG_AsVal_double(obj4, &val5);
	5010	if (!SWIG_IsOK(ecode5)) {
	5011	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "sht_SHqst_to_point" "', argument " "5"" of type '" "double""'");
	5012	}
	5013	arg5 = (double)(val5);
	5014	ecode6 = SWIG_AsVal_double(obj5, &val6);
	5015	if (!SWIG_IsOK(ecode6)) {
	5016	SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "sht_SHqst_to_point" "', argument " "6"" of type '" "double""'");
	5017	}
	5018	arg6 = (double)(val6);
	5019	{
	5020	shtns_error = 0; // clear exception
	5021	shtns_info_SHqst_to_point(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
	5022	if (shtns_error) {
	5023	// test for exception
	5024	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5025	}
	5026	}
	5027	resultobj = SWIG_Py_Void();
	5028	if (SWIG_IsTmpObj(res7)) {
	5029	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg7)));
	5030	} else {
	5031	int new_flags = SWIG_IsNewObj(res7) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	5032	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg7), SWIGTYPE_p_double, new_flags));
	5033	}
	5034	if (SWIG_IsTmpObj(res8)) {
	5035	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg8)));
	5036	} else {
	5037	int new_flags = SWIG_IsNewObj(res8) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	5038	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg8), SWIGTYPE_p_double, new_flags));
	5039	}
	5040	if (SWIG_IsTmpObj(res9)) {
	5041	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_double((*arg9)));
	5042	} else {
	5043	int new_flags = SWIG_IsNewObj(res9) ? (SWIG_POINTER_OWN \| 0 ) : 0 ;
	5044	resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg9), SWIGTYPE_p_double, new_flags));
	5045	}
	5046	return resultobj;
	5047	fail:
	5048	return NULL;
	5049	}
	5050
	5051
	5052	SWIGINTERN PyObject _wrap_sht_Zrotate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5053	PyObject *resultobj = 0;
	5054	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5055	PyObject arg2 = (PyObject ) 0 ;
	5056	double arg3 ;
	5057	void *argp1 = 0 ;
	5058	int res1 = 0 ;
	5059	double val3 ;
	5060	int ecode3 = 0 ;
	5061	PyObject * obj0 = 0 ;
	5062	PyObject * obj1 = 0 ;
	5063	PyObject * obj2 = 0 ;
	5064	PyObject *result = 0 ;
	5065
	5066	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_Zrotate",&obj0,&obj1,&obj2)) SWIG_fail;
	5067	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5068	if (!SWIG_IsOK(res1)) {
	5069	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_Zrotate" "', argument " "1"" of type '" "struct shtns_info *""'");
	5070	}
	5071	arg1 = (struct shtns_info *)(argp1);
	5072	arg2 = obj1;
	5073	ecode3 = SWIG_AsVal_double(obj2, &val3);
	5074	if (!SWIG_IsOK(ecode3)) {
	5075	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_Zrotate" "', argument " "3"" of type '" "double""'");
	5076	}
	5077	arg3 = (double)(val3);
	5078	{
	5079	shtns_error = 0; // clear exception
	5080	result = (PyObject *)shtns_info_Zrotate(arg1,arg2,arg3);
	5081	if (shtns_error) {
	5082	// test for exception
	5083	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5084	}
	5085	}
	5086	resultobj = result;
	5087	return resultobj;
	5088	fail:
	5089	return NULL;
	5090	}
	5091
	5092
	5093	SWIGINTERN PyObject _wrap_sht_Yrotate(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5094	PyObject *resultobj = 0;
	5095	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5096	PyObject arg2 = (PyObject ) 0 ;
	5097	double arg3 ;
	5098	void *argp1 = 0 ;
	5099	int res1 = 0 ;
	5100	double val3 ;
	5101	int ecode3 = 0 ;
	5102	PyObject * obj0 = 0 ;
	5103	PyObject * obj1 = 0 ;
	5104	PyObject * obj2 = 0 ;
	5105	PyObject *result = 0 ;
	5106
	5107	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_Yrotate",&obj0,&obj1,&obj2)) SWIG_fail;
	5108	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5109	if (!SWIG_IsOK(res1)) {
	5110	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_Yrotate" "', argument " "1"" of type '" "struct shtns_info *""'");
	5111	}
	5112	arg1 = (struct shtns_info *)(argp1);
	5113	arg2 = obj1;
	5114	ecode3 = SWIG_AsVal_double(obj2, &val3);
	5115	if (!SWIG_IsOK(ecode3)) {
	5116	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sht_Yrotate" "', argument " "3"" of type '" "double""'");
	5117	}
	5118	arg3 = (double)(val3);
	5119	{
	5120	shtns_error = 0; // clear exception
	5121	result = (PyObject *)shtns_info_Yrotate(arg1,arg2,arg3);
	5122	if (shtns_error) {
	5123	// test for exception
	5124	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5125	}
	5126	}
	5127	resultobj = result;
	5128	return resultobj;
	5129	fail:
	5130	return NULL;
	5131	}
	5132
	5133
	5134	SWIGINTERN PyObject _wrap_sht_Yrotate90(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5135	PyObject *resultobj = 0;
	5136	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5137	PyObject arg2 = (PyObject ) 0 ;
	5138	void *argp1 = 0 ;
	5139	int res1 = 0 ;
	5140	PyObject * obj0 = 0 ;
	5141	PyObject * obj1 = 0 ;
	5142	PyObject *result = 0 ;
	5143
	5144	if (!PyArg_ParseTuple(args,(char *)"OO:sht_Yrotate90",&obj0,&obj1)) SWIG_fail;
	5145	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5146	if (!SWIG_IsOK(res1)) {
	5147	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_Yrotate90" "', argument " "1"" of type '" "struct shtns_info *""'");
	5148	}
	5149	arg1 = (struct shtns_info *)(argp1);
	5150	arg2 = obj1;
	5151	{
	5152	shtns_error = 0; // clear exception
	5153	result = (PyObject *)shtns_info_Yrotate90(arg1,arg2);
	5154	if (shtns_error) {
	5155	// test for exception
	5156	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5157	}
	5158	}
	5159	resultobj = result;
	5160	return resultobj;
	5161	fail:
	5162	return NULL;
	5163	}
	5164
	5165
	5166	SWIGINTERN PyObject _wrap_sht_Xrotate90(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5167	PyObject *resultobj = 0;
	5168	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5169	PyObject arg2 = (PyObject ) 0 ;
	5170	void *argp1 = 0 ;
	5171	int res1 = 0 ;
	5172	PyObject * obj0 = 0 ;
	5173	PyObject * obj1 = 0 ;
	5174	PyObject *result = 0 ;
	5175
	5176	if (!PyArg_ParseTuple(args,(char *)"OO:sht_Xrotate90",&obj0,&obj1)) SWIG_fail;
	5177	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5178	if (!SWIG_IsOK(res1)) {
	5179	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_Xrotate90" "', argument " "1"" of type '" "struct shtns_info *""'");
	5180	}
	5181	arg1 = (struct shtns_info *)(argp1);
	5182	arg2 = obj1;
	5183	{
	5184	shtns_error = 0; // clear exception
	5185	result = (PyObject *)shtns_info_Xrotate90(arg1,arg2);
	5186	if (shtns_error) {
	5187	// test for exception
	5188	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5189	}
	5190	}
	5191	resultobj = result;
	5192	return resultobj;
	5193	fail:
	5194	return NULL;
	5195	}
	5196
	5197
	5198	SWIGINTERN PyObject _wrap_sht_SH_mul_mx(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5199	PyObject *resultobj = 0;
	5200	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5201	PyObject arg2 = (PyObject ) 0 ;
	5202	PyObject arg3 = (PyObject ) 0 ;
	5203	void *argp1 = 0 ;
	5204	int res1 = 0 ;
	5205	PyObject * obj0 = 0 ;
	5206	PyObject * obj1 = 0 ;
	5207	PyObject * obj2 = 0 ;
	5208	PyObject *result = 0 ;
	5209
	5210	if (!PyArg_ParseTuple(args,(char *)"OOO:sht_SH_mul_mx",&obj0,&obj1,&obj2)) SWIG_fail;
	5211	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5212	if (!SWIG_IsOK(res1)) {
	5213	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_mul_mx" "', argument " "1"" of type '" "struct shtns_info *""'");
	5214	}
	5215	arg1 = (struct shtns_info *)(argp1);
	5216	arg2 = obj1;
	5217	arg3 = obj2;
	5218	{
	5219	shtns_error = 0; // clear exception
	5220	result = (PyObject *)shtns_info_SH_mul_mx(arg1,arg2,arg3);
	5221	if (shtns_error) {
	5222	// test for exception
	5223	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5224	}
	5225	}
	5226	resultobj = result;
	5227	return resultobj;
	5228	fail:
	5229	return NULL;
	5230	}
	5231
	5232
	5233	SWIGINTERN PyObject _wrap_sht_spat_to_SH_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5234	PyObject *resultobj = 0;
	5235	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5236	PyObject arg2 = (PyObject ) 0 ;
	5237	PyObject arg3 = (PyObject ) 0 ;
	5238	PyObject arg4 = (PyObject ) 0 ;
	5239	void *argp1 = 0 ;
	5240	int res1 = 0 ;
	5241	PyObject * obj0 = 0 ;
	5242	PyObject * obj1 = 0 ;
	5243	PyObject * obj2 = 0 ;
	5244	PyObject * obj3 = 0 ;
	5245
	5246	if (!PyArg_ParseTuple(args,(char *)"OOOO:sht_spat_to_SH_m",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	5247	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5248	if (!SWIG_IsOK(res1)) {
	5249	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SH_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5250	}
	5251	arg1 = (struct shtns_info *)(argp1);
	5252	arg2 = obj1;
	5253	arg3 = obj2;
	5254	arg4 = obj3;
	5255	{
	5256	shtns_error = 0; // clear exception
	5257	shtns_info_spat_to_SH_m(arg1,arg2,arg3,arg4);
	5258	if (shtns_error) {
	5259	// test for exception
	5260	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5261	}
	5262	}
	5263	resultobj = SWIG_Py_Void();
	5264	return resultobj;
	5265	fail:
	5266	return NULL;
	5267	}
	5268
	5269
	5270	SWIGINTERN PyObject _wrap_sht_SH_to_spat_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5271	PyObject *resultobj = 0;
	5272	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5273	PyObject arg2 = (PyObject ) 0 ;
	5274	PyObject arg3 = (PyObject ) 0 ;
	5275	PyObject arg4 = (PyObject ) 0 ;
	5276	void *argp1 = 0 ;
	5277	int res1 = 0 ;
	5278	PyObject * obj0 = 0 ;
	5279	PyObject * obj1 = 0 ;
	5280	PyObject * obj2 = 0 ;
	5281	PyObject * obj3 = 0 ;
	5282
	5283	if (!PyArg_ParseTuple(args,(char *)"OOOO:sht_SH_to_spat_m",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
	5284	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5285	if (!SWIG_IsOK(res1)) {
	5286	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SH_to_spat_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5287	}
	5288	arg1 = (struct shtns_info *)(argp1);
	5289	arg2 = obj1;
	5290	arg3 = obj2;
	5291	arg4 = obj3;
	5292	{
	5293	shtns_error = 0; // clear exception
	5294	shtns_info_SH_to_spat_m(arg1,arg2,arg3,arg4);
	5295	if (shtns_error) {
	5296	// test for exception
	5297	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5298	}
	5299	}
	5300	resultobj = SWIG_Py_Void();
	5301	return resultobj;
	5302	fail:
	5303	return NULL;
	5304	}
	5305
	5306
	5307	SWIGINTERN PyObject _wrap_sht_spat_to_SHsphtor_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5308	PyObject *resultobj = 0;
	5309	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5310	PyObject arg2 = (PyObject ) 0 ;
	5311	PyObject arg3 = (PyObject ) 0 ;
	5312	PyObject arg4 = (PyObject ) 0 ;
	5313	PyObject arg5 = (PyObject ) 0 ;
	5314	PyObject arg6 = (PyObject ) 0 ;
	5315	void *argp1 = 0 ;
	5316	int res1 = 0 ;
	5317	PyObject * obj0 = 0 ;
	5318	PyObject * obj1 = 0 ;
	5319	PyObject * obj2 = 0 ;
	5320	PyObject * obj3 = 0 ;
	5321	PyObject * obj4 = 0 ;
	5322	PyObject * obj5 = 0 ;
	5323
	5324	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:sht_spat_to_SHsphtor_m",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	5325	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5326	if (!SWIG_IsOK(res1)) {
	5327	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SHsphtor_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5328	}
	5329	arg1 = (struct shtns_info *)(argp1);
	5330	arg2 = obj1;
	5331	arg3 = obj2;
	5332	arg4 = obj3;
	5333	arg5 = obj4;
	5334	arg6 = obj5;
	5335	{
	5336	shtns_error = 0; // clear exception
	5337	shtns_info_spat_to_SHsphtor_m(arg1,arg2,arg3,arg4,arg5,arg6);
	5338	if (shtns_error) {
	5339	// test for exception
	5340	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5341	}
	5342	}
	5343	resultobj = SWIG_Py_Void();
	5344	return resultobj;
	5345	fail:
	5346	return NULL;
	5347	}
	5348
	5349
	5350	SWIGINTERN PyObject _wrap_sht_SHsphtor_to_spat_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5351	PyObject *resultobj = 0;
	5352	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5353	PyObject arg2 = (PyObject ) 0 ;
	5354	PyObject arg3 = (PyObject ) 0 ;
	5355	PyObject arg4 = (PyObject ) 0 ;
	5356	PyObject arg5 = (PyObject ) 0 ;
	5357	PyObject arg6 = (PyObject ) 0 ;
	5358	void *argp1 = 0 ;
	5359	int res1 = 0 ;
	5360	PyObject * obj0 = 0 ;
	5361	PyObject * obj1 = 0 ;
	5362	PyObject * obj2 = 0 ;
	5363	PyObject * obj3 = 0 ;
	5364	PyObject * obj4 = 0 ;
	5365	PyObject * obj5 = 0 ;
	5366
	5367	if (!PyArg_ParseTuple(args,(char *)"OOOOOO:sht_SHsphtor_to_spat_m",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
	5368	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5369	if (!SWIG_IsOK(res1)) {
	5370	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHsphtor_to_spat_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5371	}
	5372	arg1 = (struct shtns_info *)(argp1);
	5373	arg2 = obj1;
	5374	arg3 = obj2;
	5375	arg4 = obj3;
	5376	arg5 = obj4;
	5377	arg6 = obj5;
	5378	{
	5379	shtns_error = 0; // clear exception
	5380	shtns_info_SHsphtor_to_spat_m(arg1,arg2,arg3,arg4,arg5,arg6);
	5381	if (shtns_error) {
	5382	// test for exception
	5383	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5384	}
	5385	}
	5386	resultobj = SWIG_Py_Void();
	5387	return resultobj;
	5388	fail:
	5389	return NULL;
	5390	}
	5391
	5392
	5393	SWIGINTERN PyObject _wrap_sht_SHsph_to_spat_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5394	PyObject *resultobj = 0;
	5395	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5396	PyObject arg2 = (PyObject ) 0 ;
	5397	PyObject arg3 = (PyObject ) 0 ;
	5398	PyObject arg4 = (PyObject ) 0 ;
	5399	PyObject arg5 = (PyObject ) 0 ;
	5400	void *argp1 = 0 ;
	5401	int res1 = 0 ;
	5402	PyObject * obj0 = 0 ;
	5403	PyObject * obj1 = 0 ;
	5404	PyObject * obj2 = 0 ;
	5405	PyObject * obj3 = 0 ;
	5406	PyObject * obj4 = 0 ;
	5407
	5408	if (!PyArg_ParseTuple(args,(char *)"OOOOO:sht_SHsph_to_spat_m",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	5409	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5410	if (!SWIG_IsOK(res1)) {
	5411	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHsph_to_spat_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5412	}
	5413	arg1 = (struct shtns_info *)(argp1);
	5414	arg2 = obj1;
	5415	arg3 = obj2;
	5416	arg4 = obj3;
	5417	arg5 = obj4;
	5418	{
	5419	shtns_error = 0; // clear exception
	5420	shtns_info_SHsph_to_spat_m(arg1,arg2,arg3,arg4,arg5);
	5421	if (shtns_error) {
	5422	// test for exception
	5423	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5424	}
	5425	}
	5426	resultobj = SWIG_Py_Void();
	5427	return resultobj;
	5428	fail:
	5429	return NULL;
	5430	}
	5431
	5432
	5433	SWIGINTERN PyObject _wrap_sht_SHtor_to_spat_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5434	PyObject *resultobj = 0;
	5435	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5436	PyObject arg2 = (PyObject ) 0 ;
	5437	PyObject arg3 = (PyObject ) 0 ;
	5438	PyObject arg4 = (PyObject ) 0 ;
	5439	PyObject arg5 = (PyObject ) 0 ;
	5440	void *argp1 = 0 ;
	5441	int res1 = 0 ;
	5442	PyObject * obj0 = 0 ;
	5443	PyObject * obj1 = 0 ;
	5444	PyObject * obj2 = 0 ;
	5445	PyObject * obj3 = 0 ;
	5446	PyObject * obj4 = 0 ;
	5447
	5448	if (!PyArg_ParseTuple(args,(char *)"OOOOO:sht_SHtor_to_spat_m",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
	5449	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5450	if (!SWIG_IsOK(res1)) {
	5451	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHtor_to_spat_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5452	}
	5453	arg1 = (struct shtns_info *)(argp1);
	5454	arg2 = obj1;
	5455	arg3 = obj2;
	5456	arg4 = obj3;
	5457	arg5 = obj4;
	5458	{
	5459	shtns_error = 0; // clear exception
	5460	shtns_info_SHtor_to_spat_m(arg1,arg2,arg3,arg4,arg5);
	5461	if (shtns_error) {
	5462	// test for exception
	5463	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5464	}
	5465	}
	5466	resultobj = SWIG_Py_Void();
	5467	return resultobj;
	5468	fail:
	5469	return NULL;
	5470	}
	5471
	5472
	5473	SWIGINTERN PyObject _wrap_sht_spat_to_SHqst_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5474	PyObject *resultobj = 0;
	5475	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5476	PyObject arg2 = (PyObject ) 0 ;
	5477	PyObject arg3 = (PyObject ) 0 ;
	5478	PyObject arg4 = (PyObject ) 0 ;
	5479	PyObject arg5 = (PyObject ) 0 ;
	5480	PyObject arg6 = (PyObject ) 0 ;
	5481	PyObject arg7 = (PyObject ) 0 ;
	5482	PyObject arg8 = (PyObject ) 0 ;
	5483	void *argp1 = 0 ;
	5484	int res1 = 0 ;
	5485	PyObject * obj0 = 0 ;
	5486	PyObject * obj1 = 0 ;
	5487	PyObject * obj2 = 0 ;
	5488	PyObject * obj3 = 0 ;
	5489	PyObject * obj4 = 0 ;
	5490	PyObject * obj5 = 0 ;
	5491	PyObject * obj6 = 0 ;
	5492	PyObject * obj7 = 0 ;
	5493
	5494	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:sht_spat_to_SHqst_m",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
	5495	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5496	if (!SWIG_IsOK(res1)) {
	5497	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_spat_to_SHqst_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5498	}
	5499	arg1 = (struct shtns_info *)(argp1);
	5500	arg2 = obj1;
	5501	arg3 = obj2;
	5502	arg4 = obj3;
	5503	arg5 = obj4;
	5504	arg6 = obj5;
	5505	arg7 = obj6;
	5506	arg8 = obj7;
	5507	{
	5508	shtns_error = 0; // clear exception
	5509	shtns_info_spat_to_SHqst_m(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
	5510	if (shtns_error) {
	5511	// test for exception
	5512	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5513	}
	5514	}
	5515	resultobj = SWIG_Py_Void();
	5516	return resultobj;
	5517	fail:
	5518	return NULL;
	5519	}
	5520
	5521
	5522	SWIGINTERN PyObject _wrap_sht_SHqst_to_spat_m(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5523	PyObject *resultobj = 0;
	5524	struct shtns_info arg1 = (struct shtns_info ) 0 ;
	5525	PyObject arg2 = (PyObject ) 0 ;
	5526	PyObject arg3 = (PyObject ) 0 ;
	5527	PyObject arg4 = (PyObject ) 0 ;
	5528	PyObject arg5 = (PyObject ) 0 ;
	5529	PyObject arg6 = (PyObject ) 0 ;
	5530	PyObject arg7 = (PyObject ) 0 ;
	5531	PyObject arg8 = (PyObject ) 0 ;
	5532	void *argp1 = 0 ;
	5533	int res1 = 0 ;
	5534	PyObject * obj0 = 0 ;
	5535	PyObject * obj1 = 0 ;
	5536	PyObject * obj2 = 0 ;
	5537	PyObject * obj3 = 0 ;
	5538	PyObject * obj4 = 0 ;
	5539	PyObject * obj5 = 0 ;
	5540	PyObject * obj6 = 0 ;
	5541	PyObject * obj7 = 0 ;
	5542
	5543	if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:sht_SHqst_to_spat_m",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
	5544	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shtns_info, 0 \| 0 );
	5545	if (!SWIG_IsOK(res1)) {
	5546	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sht_SHqst_to_spat_m" "', argument " "1"" of type '" "struct shtns_info *""'");
	5547	}
	5548	arg1 = (struct shtns_info *)(argp1);
	5549	arg2 = obj1;
	5550	arg3 = obj2;
	5551	arg4 = obj3;
	5552	arg5 = obj4;
	5553	arg6 = obj5;
	5554	arg7 = obj6;
	5555	arg8 = obj7;
	5556	{
	5557	shtns_error = 0; // clear exception
	5558	shtns_info_SHqst_to_spat_m(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
	5559	if (shtns_error) {
	5560	// test for exception
	5561	SWIG_exception(shtns_error, shtns_err_msg); return NULL;
	5562	}
	5563	}
	5564	resultobj = SWIG_Py_Void();
	5565	return resultobj;
	5566	fail:
	5567	return NULL;
	5568	}
	5569
	5570
	5571	SWIGINTERN PyObject sht_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5572	PyObject *obj;
	5573	if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
	5574	SWIG_TypeNewClientData(SWIGTYPE_p_shtns_info, SWIG_NewClientData(obj));
	5575	return SWIG_Py_Void();
	5576	}
	5577
	5578	SWIGINTERN PyObject _wrap_nlm_calc(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5579	PyObject *resultobj = 0;
	5580	long arg1 ;
	5581	long arg2 ;
	5582	long arg3 ;
	5583	long val1 ;
	5584	int ecode1 = 0 ;
	5585	long val2 ;
	5586	int ecode2 = 0 ;
	5587	long val3 ;
	5588	int ecode3 = 0 ;
	5589	PyObject * obj0 = 0 ;
	5590	PyObject * obj1 = 0 ;
	5591	PyObject * obj2 = 0 ;
	5592	long result;
	5593
	5594	if (!PyArg_ParseTuple(args,(char *)"OOO:nlm_calc",&obj0,&obj1,&obj2)) SWIG_fail;
	5595	ecode1 = SWIG_AsVal_long(obj0, &val1);
	5596	if (!SWIG_IsOK(ecode1)) {
	5597	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "nlm_calc" "', argument " "1"" of type '" "long""'");
	5598	}
	5599	arg1 = (long)(val1);
	5600	ecode2 = SWIG_AsVal_long(obj1, &val2);
	5601	if (!SWIG_IsOK(ecode2)) {
	5602	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nlm_calc" "', argument " "2"" of type '" "long""'");
	5603	}
	5604	arg2 = (long)(val2);
	5605	ecode3 = SWIG_AsVal_long(obj2, &val3);
	5606	if (!SWIG_IsOK(ecode3)) {
	5607	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nlm_calc" "', argument " "3"" of type '" "long""'");
	5608	}
	5609	arg3 = (long)(val3);
	5610	result = (long)nlm_calc(arg1,arg2,arg3);
	5611	resultobj = SWIG_From_long((long)(result));
	5612	return resultobj;
	5613	fail:
	5614	return NULL;
	5615	}
	5616
	5617
	5618	SWIGINTERN PyObject _wrap_set_verbosity(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5619	PyObject *resultobj = 0;
	5620	int arg1 ;
	5621	int val1 ;
	5622	int ecode1 = 0 ;
	5623	PyObject * obj0 = 0 ;
	5624
	5625	if (!PyArg_ParseTuple(args,(char *)"O:set_verbosity",&obj0)) SWIG_fail;
	5626	ecode1 = SWIG_AsVal_int(obj0, &val1);
	5627	if (!SWIG_IsOK(ecode1)) {
	5628	SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "set_verbosity" "', argument " "1"" of type '" "int""'");
	5629	}
	5630	arg1 = (int)(val1);
	5631	shtns_verbose(arg1);
	5632	resultobj = SWIG_Py_Void();
	5633	return resultobj;
	5634	fail:
	5635	return NULL;
	5636	}
	5637
	5638
	5639	SWIGINTERN PyObject _wrap_print_version(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
	5640	PyObject *resultobj = 0;
	5641
	5642	if (!PyArg_ParseTuple(args,(char *)":print_version")) SWIG_fail;
	5643	shtns_print_version();
	5644	resultobj = SWIG_Py_Void();
	5645	return resultobj;
	5646	fail:
	5647	return NULL;
	5648	}
	5649
	5650
	5651	static PyMethodDef SwigMethods[] = {
	5652	{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
	5653	{ (char *)"sht_orthonormal_swigconstant", sht_orthonormal_swigconstant, METH_VARARGS, NULL},
	5654	{ (char *)"sht_fourpi_swigconstant", sht_fourpi_swigconstant, METH_VARARGS, NULL},
	5655	{ (char *)"sht_schmidt_swigconstant", sht_schmidt_swigconstant, METH_VARARGS, NULL},
	5656	{ (char *)"SHT_NO_CS_PHASE_swigconstant", SHT_NO_CS_PHASE_swigconstant, METH_VARARGS, NULL},
	5657	{ (char *)"SHT_REAL_NORM_swigconstant", SHT_REAL_NORM_swigconstant, METH_VARARGS, NULL},
	5658	{ (char *)"sht_gauss_swigconstant", sht_gauss_swigconstant, METH_VARARGS, NULL},
	5659	{ (char *)"sht_auto_swigconstant", sht_auto_swigconstant, METH_VARARGS, NULL},
	5660	{ (char *)"sht_reg_fast_swigconstant", sht_reg_fast_swigconstant, METH_VARARGS, NULL},
	5661	{ (char *)"sht_reg_dct_swigconstant", sht_reg_dct_swigconstant, METH_VARARGS, NULL},
	5662	{ (char *)"sht_quick_init_swigconstant", sht_quick_init_swigconstant, METH_VARARGS, NULL},
	5663	{ (char *)"sht_reg_poles_swigconstant", sht_reg_poles_swigconstant, METH_VARARGS, NULL},
	5664	{ (char *)"sht_gauss_fly_swigconstant", sht_gauss_fly_swigconstant, METH_VARARGS, NULL},
	5665	{ (char *)"SHT_THETA_CONTIGUOUS_swigconstant", SHT_THETA_CONTIGUOUS_swigconstant, METH_VARARGS, NULL},
	5666	{ (char *)"SHT_PHI_CONTIGUOUS_swigconstant", SHT_PHI_CONTIGUOUS_swigconstant, METH_VARARGS, NULL},
	5667	{ (char *)"SHT_SOUTH_POLE_FIRST_swigconstant", SHT_SOUTH_POLE_FIRST_swigconstant, METH_VARARGS, NULL},
	5668	{ (char *)"SHT_SCALAR_ONLY_swigconstant", SHT_SCALAR_ONLY_swigconstant, METH_VARARGS, NULL},
	5669	{ (char *)"SHT_LOAD_SAVE_CFG_swigconstant", SHT_LOAD_SAVE_CFG_swigconstant, METH_VARARGS, NULL},
	5670	{ (char )"sht_nlm_get", _wrap_sht_nlm_get, METH_VARARGS, (char )"sht_nlm_get(sht self) -> unsigned int const"},
	5671	{ (char )"sht_lmax_get", _wrap_sht_lmax_get, METH_VARARGS, (char )"sht_lmax_get(sht self) -> unsigned short const"},
	5672	{ (char )"sht_mmax_get", _wrap_sht_mmax_get, METH_VARARGS, (char )"sht_mmax_get(sht self) -> unsigned short const"},
	5673	{ (char )"sht_mres_get", _wrap_sht_mres_get, METH_VARARGS, (char )"sht_mres_get(sht self) -> unsigned short const"},
	5674	{ (char )"sht_nphi_get", _wrap_sht_nphi_get, METH_VARARGS, (char )"sht_nphi_get(sht self) -> unsigned short const"},
	5675	{ (char )"sht_nlat_get", _wrap_sht_nlat_get, METH_VARARGS, (char )"sht_nlat_get(sht self) -> unsigned short const"},
	5676	{ (char )"sht_nspat_get", _wrap_sht_nspat_get, METH_VARARGS, (char )"sht_nspat_get(sht self) -> unsigned int const"},
	5677	{ (char )"new_sht", (PyCFunction) _wrap_new_sht, METH_VARARGS \| METH_KEYWORDS, (char )"new_sht(int lmax, int mmax=-1, int mres=1, int norm=sht_orthonormal, int nthreads=0) -> sht"},
	5678	{ (char )"delete_sht", _wrap_delete_sht, METH_VARARGS, (char )"delete_sht(sht self)"},
	5679	{ (char )"sht_set_grid", (PyCFunction) _wrap_sht_set_grid, METH_VARARGS \| METH_KEYWORDS, (char )"sht_set_grid(sht self, int nlat=0, int nphi=0, int flags=sht_quick_init, double polar_opt=1.0e-8, int nl_order=1)"},
	5680	{ (char )"sht_print_info", _wrap_sht_print_info, METH_VARARGS, (char )"sht_print_info(sht self)"},
	5681	{ (char )"sht_sh00_1", _wrap_sht_sh00_1, METH_VARARGS, (char )"sht_sh00_1(sht self) -> double"},
	5682	{ (char )"sht_sh10_ct", _wrap_sht_sh10_ct, METH_VARARGS, (char )"sht_sh10_ct(sht self) -> double"},
	5683	{ (char )"sht_sh11_st", _wrap_sht_sh11_st, METH_VARARGS, (char )"sht_sh11_st(sht self) -> double"},
	5684	{ (char )"sht_shlm_e1", _wrap_sht_shlm_e1, METH_VARARGS, (char )"sht_shlm_e1(sht self, unsigned int l, unsigned int m) -> double"},
	5685	{ (char )"sht___ct", _wrap_sht___ct, METH_VARARGS, (char )"sht___ct(sht self) -> PyObject *"},
	5686	{ (char )"sht_gauss_wts", _wrap_sht_gauss_wts, METH_VARARGS, (char )"sht_gauss_wts(sht self) -> PyObject *"},
	5687	{ (char )"sht_mul_ct_matrix", _wrap_sht_mul_ct_matrix, METH_VARARGS, (char )"sht_mul_ct_matrix(sht self) -> PyObject *"},
	5688	{ (char )"sht_st_dt_matrix", _wrap_sht_st_dt_matrix, METH_VARARGS, (char )"sht_st_dt_matrix(sht self) -> PyObject *"},
	5689	{ (char )"sht___spat_shape", _wrap_sht___spat_shape, METH_VARARGS, (char )"sht___spat_shape(sht self)"},
	5690	{ (char )"sht_idx", _wrap_sht_idx, METH_VARARGS, (char )"sht_idx(sht self, unsigned int l, unsigned int m) -> int"},
	5691	{ (char )"sht_spat_to_SH", _wrap_sht_spat_to_SH, METH_VARARGS, (char )"sht_spat_to_SH(sht self, PyObject * Vr, PyObject * Qlm)"},
	5692	{ (char )"sht_SH_to_spat", _wrap_sht_SH_to_spat, METH_VARARGS, (char )"sht_SH_to_spat(sht self, PyObject * Qlm, PyObject * Vr)"},
	5693	{ (char )"sht_spat_cplx_to_SH", _wrap_sht_spat_cplx_to_SH, METH_VARARGS, (char )"sht_spat_cplx_to_SH(sht self, PyObject * z, PyObject * alm)"},
	5694	{ (char )"sht_SH_to_spat_cplx", _wrap_sht_SH_to_spat_cplx, METH_VARARGS, (char )"sht_SH_to_spat_cplx(sht self, PyObject * alm, PyObject * z)"},
	5695	{ (char )"sht_spat_to_SHsphtor", _wrap_sht_spat_to_SHsphtor, METH_VARARGS, (char )"sht_spat_to_SHsphtor(sht self, PyObject * Vt, PyObject * Vp, PyObject * Slm, PyObject * Tlm)"},
	5696	{ (char )"sht_SHsphtor_to_spat", _wrap_sht_SHsphtor_to_spat, METH_VARARGS, (char )"sht_SHsphtor_to_spat(sht self, PyObject * Slm, PyObject * Tlm, PyObject * Vt, PyObject * Vp)"},
	5697	{ (char )"sht_SHsph_to_spat", _wrap_sht_SHsph_to_spat, METH_VARARGS, (char )"sht_SHsph_to_spat(sht self, PyObject * Slm, PyObject * Vt, PyObject * Vp)"},
	5698	{ (char )"sht_SHtor_to_spat", _wrap_sht_SHtor_to_spat, METH_VARARGS, (char )"sht_SHtor_to_spat(sht self, PyObject * Tlm, PyObject * Vt, PyObject * Vp)"},
	5699	{ (char )"sht_spat_to_SHqst", _wrap_sht_spat_to_SHqst, METH_VARARGS, (char )"sht_spat_to_SHqst(sht self, PyObject * Vr, PyObject * Vt, PyObject * Vp, PyObject * Qlm, PyObject * Slm, PyObject * Tlm)"},
	5700	{ (char )"sht_SHqst_to_spat", _wrap_sht_SHqst_to_spat, METH_VARARGS, (char )"sht_SHqst_to_spat(sht self, PyObject * Qlm, PyObject * Slm, PyObject * Tlm, PyObject * Vr, PyObject * Vt, PyObject * Vp)"},
	5701	{ (char )"sht_SH_to_point", _wrap_sht_SH_to_point, METH_VARARGS, (char )"sht_SH_to_point(sht self, PyObject * Qlm, double cost, double phi) -> double"},
	5702	{ (char )"sht_SH_to_grad_point", _wrap_sht_SH_to_grad_point, METH_VARARGS, (char )"sht_SH_to_grad_point(sht self, PyObject * DrSlm, PyObject * Slm, double cost, double phi)"},
	5703	{ (char )"sht_SHqst_to_point", _wrap_sht_SHqst_to_point, METH_VARARGS, (char )"sht_SHqst_to_point(sht self, PyObject * Qlm, PyObject * Slm, PyObject * Tlm, double cost, double phi)"},
	5704	{ (char )"sht_Zrotate", _wrap_sht_Zrotate, METH_VARARGS, (char )"sht_Zrotate(sht self, PyObject * Qlm, double alpha) -> PyObject *"},
	5705	{ (char )"sht_Yrotate", _wrap_sht_Yrotate, METH_VARARGS, (char )"sht_Yrotate(sht self, PyObject * Qlm, double alpha) -> PyObject *"},
	5706	{ (char )"sht_Yrotate90", _wrap_sht_Yrotate90, METH_VARARGS, (char )"sht_Yrotate90(sht self, PyObject * Qlm) -> PyObject *"},
	5707	{ (char )"sht_Xrotate90", _wrap_sht_Xrotate90, METH_VARARGS, (char )"sht_Xrotate90(sht self, PyObject * Qlm) -> PyObject *"},
	5708	{ (char )"sht_SH_mul_mx", _wrap_sht_SH_mul_mx, METH_VARARGS, (char )"sht_SH_mul_mx(sht self, PyObject * mx, PyObject * Qlm) -> PyObject *"},
	5709	{ (char )"sht_spat_to_SH_m", _wrap_sht_spat_to_SH_m, METH_VARARGS, (char )"sht_spat_to_SH_m(sht self, PyObject * Vr, PyObject * Qlm, PyObject * im)"},
	5710	{ (char )"sht_SH_to_spat_m", _wrap_sht_SH_to_spat_m, METH_VARARGS, (char )"sht_SH_to_spat_m(sht self, PyObject * Qlm, PyObject * Vr, PyObject * im)"},
	5711	{ (char )"sht_spat_to_SHsphtor_m", _wrap_sht_spat_to_SHsphtor_m, METH_VARARGS, (char )"sht_spat_to_SHsphtor_m(sht self, PyObject * Vt, PyObject * Vp, PyObject * Slm, PyObject * Tlm, PyObject * im)"},
	5712	{ (char )"sht_SHsphtor_to_spat_m", _wrap_sht_SHsphtor_to_spat_m, METH_VARARGS, (char )"sht_SHsphtor_to_spat_m(sht self, PyObject * Slm, PyObject * Tlm, PyObject * Vt, PyObject * Vp, PyObject * im)"},
	5713	{ (char )"sht_SHsph_to_spat_m", _wrap_sht_SHsph_to_spat_m, METH_VARARGS, (char )"sht_SHsph_to_spat_m(sht self, PyObject * Slm, PyObject * Vt, PyObject * Vp, PyObject * im)"},
	5714	{ (char )"sht_SHtor_to_spat_m", _wrap_sht_SHtor_to_spat_m, METH_VARARGS, (char )"sht_SHtor_to_spat_m(sht self, PyObject * Tlm, PyObject * Vt, PyObject * Vp, PyObject * im)"},
	5715	{ (char )"sht_spat_to_SHqst_m", _wrap_sht_spat_to_SHqst_m, METH_VARARGS, (char )"sht_spat_to_SHqst_m(sht self, PyObject * Vr, PyObject * Vt, PyObject * Vp, PyObject * Qlm, PyObject * Slm, PyObject * Tlm, PyObject * im)"},
	5716	{ (char )"sht_SHqst_to_spat_m", _wrap_sht_SHqst_to_spat_m, METH_VARARGS, (char )"sht_SHqst_to_spat_m(sht self, PyObject * Qlm, PyObject * Slm, PyObject * Tlm, PyObject * Vr, PyObject * Vt, PyObject * Vp, PyObject * im)"},
	5717	{ (char *)"sht_swigregister", sht_swigregister, METH_VARARGS, NULL},
	5718	{ (char )"nlm_calc", _wrap_nlm_calc, METH_VARARGS, (char )"nlm_calc(long lmax, long mmax, long mres) -> long"},
	5719	{ (char )"set_verbosity", _wrap_set_verbosity, METH_VARARGS, (char )"set_verbosity(int arg1)"},
	5720	{ (char )"print_version", _wrap_print_version, METH_VARARGS, (char )"print_version()"},
	5721	{ NULL, NULL, 0, NULL }
	5722	};
	5723
	5724
	5725	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
	5726
	5727	static swig_type_info _swigt__p_char = {"_p_char", "char ", 0, 0, (void)0, 0};
	5728	static swig_type_info _swigt__p_double = {"_p_double", "double ", 0, 0, (void)0, 0};
	5729	static swig_type_info _swigt__p_double_complex = {"_p_double_complex", "cplx \|double complex ", 0, 0, (void*)0, 0};
	5730	static swig_type_info _swigt__p_int = {"_p_int", "int ", 0, 0, (void)0, 0};
	5731	static swig_type_info _swigt__p_shtns_info = {"_p_shtns_info", "struct shtns_info \|shtns_info ", 0, 0, (void*)0, 0};
	5732
	5733	static swig_type_info *swig_type_initial[] = {
	5734	&_swigt__p_char,
	5735	&_swigt__p_double,
	5736	&_swigt__p_double_complex,
	5737	&_swigt__p_int,
	5738	&_swigt__p_shtns_info,
	5739	};
	5740
	5741	static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
	5742	static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
	5743	static swig_cast_info _swigc__p_double_complex[] = { {&_swigt__p_double_complex, 0, 0, 0},{0, 0, 0, 0}};
	5744	static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
	5745	static swig_cast_info _swigc__p_shtns_info[] = { {&_swigt__p_shtns_info, 0, 0, 0},{0, 0, 0, 0}};
	5746
	5747	static swig_cast_info *swig_cast_initial[] = {
	5748	_swigc__p_char,
	5749	_swigc__p_double,
	5750	_swigc__p_double_complex,
	5751	_swigc__p_int,
	5752	_swigc__p_shtns_info,
	5753	};
	5754
	5755
	5756	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
	5757
	5758	static swig_const_info swig_const_table[] = {
	5759	{0, 0, 0, 0.0, 0, 0}};
	5760
	5761	#ifdef __cplusplus
	5762	}
	5763	#endif
	5764	/* -----------------------------------------------------------------------------
	5765	* Type initialization:
	5766	* This problem is tough by the requirement that no dynamic
	5767	* memory is used. Also, since swig_type_info structures store pointers to
	5768	* swig_cast_info structures and swig_cast_info structures store pointers back
	5769	* to swig_type_info structures, we need some lookup code at initialization.
	5770	* The idea is that swig generates all the structures that are needed.
	5771	* The runtime then collects these partially filled structures.
	5772	* The SWIG_InitializeModule function takes these initial arrays out of
	5773	* swig_module, and does all the lookup, filling in the swig_module.types
	5774	* array with the correct data and linking the correct swig_cast_info
	5775	* structures together.
	5776	*
	5777	* The generated swig_type_info structures are assigned statically to an initial
	5778	* array. We just loop through that array, and handle each type individually.
	5779	* First we lookup if this type has been already loaded, and if so, use the
	5780	* loaded structure instead of the generated one. Then we have to fill in the
	5781	* cast linked list. The cast data is initially stored in something like a
	5782	* two-dimensional array. Each row corresponds to a type (there are the same
	5783	* number of rows as there are in the swig_type_initial array). Each entry in
	5784	* a column is one of the swig_cast_info structures for that type.
	5785	* The cast_initial array is actually an array of arrays, because each row has
	5786	* a variable number of columns. So to actually build the cast linked list,
	5787	* we find the array of casts associated with the type, and loop through it
	5788	* adding the casts to the list. The one last trick we need to do is making
	5789	* sure the type pointer in the swig_cast_info struct is correct.
	5790	*
	5791	* First off, we lookup the cast->type name to see if it is already loaded.
	5792	* There are three cases to handle:
	5793	* 1) If the cast->type has already been loaded AND the type we are adding
	5794	* casting info to has not been loaded (it is in this module), THEN we
	5795	* replace the cast->type pointer with the type pointer that has already
	5796	* been loaded.
	5797	* 2) If BOTH types (the one we are adding casting info to, and the
	5798	* cast->type) are loaded, THEN the cast info has already been loaded by
	5799	* the previous module so we just ignore it.
	5800	* 3) Finally, if cast->type has not already been loaded, then we add that
	5801	* swig_cast_info to the linked list (because the cast->type) pointer will
	5802	* be correct.
	5803	* ----------------------------------------------------------------------------- */
	5804
	5805	#ifdef __cplusplus
	5806	extern "C" {
	5807	#if 0
	5808	} /* c-mode */
	5809	#endif
	5810	#endif
	5811
	5812	#if 0
	5813	#define SWIGRUNTIME_DEBUG
	5814	#endif
	5815
	5816
	5817	SWIGRUNTIME void
	5818	SWIG_InitializeModule(void *clientdata) {
	5819	size_t i;
	5820	swig_module_info module_head, iter;
	5821	int init;
	5822
	5823	/* check to see if the circular list has been setup, if not, set it up */
	5824	if (swig_module.next==0) {
	5825	/* Initialize the swig_module */
	5826	swig_module.type_initial = swig_type_initial;
	5827	swig_module.cast_initial = swig_cast_initial;
	5828	swig_module.next = &swig_module;
	5829	init = 1;
	5830	} else {
	5831	init = 0;
	5832	}
	5833
	5834	/* Try and load any already created modules */
	5835	module_head = SWIG_GetModule(clientdata);
	5836	if (!module_head) {
	5837	/* This is the first module loaded for this interpreter */
	5838	/* so set the swig module into the interpreter */
	5839	SWIG_SetModule(clientdata, &swig_module);
	5840	} else {
	5841	/* the interpreter has loaded a SWIG module, but has it loaded this one? */
	5842	iter=module_head;
	5843	do {
	5844	if (iter==&swig_module) {
	5845	/* Our module is already in the list, so there's nothing more to do. */
	5846	return;
	5847	}
	5848	iter=iter->next;
	5849	} while (iter!= module_head);
	5850
	5851	/* otherwise we must add our module into the list */
	5852	swig_module.next = module_head->next;
	5853	module_head->next = &swig_module;
	5854	}
	5855
	5856	/* When multiple interpreters are used, a module could have already been initialized in
	5857	a different interpreter, but not yet have a pointer in this interpreter.
	5858	In this case, we do not want to continue adding types... everything should be
	5859	set up already */
	5860	if (init == 0) return;
	5861
	5862	/* Now work on filling in swig_module.types */
	5863	#ifdef SWIGRUNTIME_DEBUG
	5864	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
	5865	#endif
	5866	for (i = 0; i < swig_module.size; ++i) {
	5867	swig_type_info *type = 0;
	5868	swig_type_info *ret;
	5869	swig_cast_info *cast;
	5870
	5871	#ifdef SWIGRUNTIME_DEBUG
	5872	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
	5873	#endif
	5874
	5875	/* if there is another module already loaded */
	5876	if (swig_module.next != &swig_module) {
	5877	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
	5878	}
	5879	if (type) {
	5880	/* Overwrite clientdata field */
	5881	#ifdef SWIGRUNTIME_DEBUG
	5882	printf("SWIG_InitializeModule: found type %s\n", type->name);
	5883	#endif
	5884	if (swig_module.type_initial[i]->clientdata) {
	5885	type->clientdata = swig_module.type_initial[i]->clientdata;
	5886	#ifdef SWIGRUNTIME_DEBUG
	5887	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
	5888	#endif
	5889	}
	5890	} else {
	5891	type = swig_module.type_initial[i];
	5892	}
	5893
	5894	/* Insert casting types */
	5895	cast = swig_module.cast_initial[i];
	5896	while (cast->type) {
	5897	/* Don't need to add information already in the list */
	5898	ret = 0;
	5899	#ifdef SWIGRUNTIME_DEBUG
	5900	printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
	5901	#endif
	5902	if (swig_module.next != &swig_module) {
	5903	ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
	5904	#ifdef SWIGRUNTIME_DEBUG
	5905	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
	5906	#endif
	5907	}
	5908	if (ret) {
	5909	if (type == swig_module.type_initial[i]) {
	5910	#ifdef SWIGRUNTIME_DEBUG
	5911	printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
	5912	#endif
	5913	cast->type = ret;
	5914	ret = 0;
	5915	} else {
	5916	/* Check for casting already in the list */
	5917	swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
	5918	#ifdef SWIGRUNTIME_DEBUG
	5919	if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
	5920	#endif
	5921	if (!ocast) ret = 0;
	5922	}
	5923	}
	5924
	5925	if (!ret) {
	5926	#ifdef SWIGRUNTIME_DEBUG
	5927	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
	5928	#endif
	5929	if (type->cast) {
	5930	type->cast->prev = cast;
	5931	cast->next = type->cast;
	5932	}
	5933	type->cast = cast;
	5934	}
	5935	cast++;
	5936	}
	5937	/* Set entry in modules->types array equal to the type */
	5938	swig_module.types[i] = type;
	5939	}
	5940	swig_module.types[i] = 0;
	5941
	5942	#ifdef SWIGRUNTIME_DEBUG
	5943	printf("** SWIG_InitializeModule: Cast List ****\n");
	5944	for (i = 0; i < swig_module.size; ++i) {
	5945	int j = 0;
	5946	swig_cast_info *cast = swig_module.cast_initial[i];
	5947	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
	5948	while (cast->type) {
	5949	printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
	5950	cast++;
	5951	++j;
	5952	}
	5953	printf("---- Total casts: %d\n",j);
	5954	}
	5955	printf("** SWIG_InitializeModule: Cast List ****\n");
	5956	#endif
	5957	}
	5958
	5959	/* This function will propagate the clientdata field of type to
	5960	* any new swig_type_info structures that have been added into the list
	5961	* of equivalent types. It is like calling
	5962	* SWIG_TypeClientData(type, clientdata) a second time.
	5963	*/
	5964	SWIGRUNTIME void
	5965	SWIG_PropagateClientData(void) {
	5966	size_t i;
	5967	swig_cast_info *equiv;
	5968	static int init_run = 0;
	5969
	5970	if (init_run) return;
	5971	init_run = 1;
	5972
	5973	for (i = 0; i < swig_module.size; i++) {
	5974	if (swig_module.types[i]->clientdata) {
	5975	equiv = swig_module.types[i]->cast;
	5976	while (equiv) {
	5977	if (!equiv->converter) {
	5978	if (equiv->type && !equiv->type->clientdata)
	5979	SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
	5980	}
	5981	equiv = equiv->next;
	5982	}
	5983	}
	5984	}
	5985	}
	5986
	5987	#ifdef __cplusplus
	5988	#if 0
	5989	{
	5990	/* c-mode */
	5991	#endif
	5992	}
	5993	#endif
	5994
	5995
	5996
	5997	#ifdef __cplusplus
	5998	extern "C" {
	5999	#endif
	6000
	6001	/* Python-specific SWIG API */
	6002	#define SWIG_newvarlink() SWIG_Python_newvarlink()
	6003	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
	6004	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
	6005
	6006	/* -----------------------------------------------------------------------------
	6007	* global variable support code.
	6008	* ----------------------------------------------------------------------------- */
	6009
	6010	typedef struct swig_globalvar {
	6011	char name; / Name of global variable */
	6012	PyObject (get_attr)(void); /* Return the current value */
	6013	int (set_attr)(PyObject ); /* Set the value */
	6014	struct swig_globalvar *next;
	6015	} swig_globalvar;
	6016
	6017	typedef struct swig_varlinkobject {
	6018	PyObject_HEAD
	6019	swig_globalvar *vars;
	6020	} swig_varlinkobject;
	6021
	6022	SWIGINTERN PyObject *
	6023	swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
	6024	#if PY_VERSION_HEX >= 0x03000000
	6025	return PyUnicode_InternFromString("<Swig global variables>");
	6026	#else
	6027	return PyString_FromString("<Swig global variables>");
	6028	#endif
	6029	}
	6030
	6031	SWIGINTERN PyObject *
	6032	swig_varlink_str(swig_varlinkobject *v) {
	6033	#if PY_VERSION_HEX >= 0x03000000
	6034	PyObject *str = PyUnicode_InternFromString("(");
	6035	PyObject *tail;
	6036	PyObject *joined;
	6037	swig_globalvar *var;
	6038	for (var = v->vars; var; var=var->next) {
	6039	tail = PyUnicode_FromString(var->name);
	6040	joined = PyUnicode_Concat(str, tail);
	6041	Py_DecRef(str);
	6042	Py_DecRef(tail);
	6043	str = joined;
	6044	if (var->next) {
	6045	tail = PyUnicode_InternFromString(", ");
	6046	joined = PyUnicode_Concat(str, tail);
	6047	Py_DecRef(str);
	6048	Py_DecRef(tail);
	6049	str = joined;
	6050	}
	6051	}
	6052	tail = PyUnicode_InternFromString(")");
	6053	joined = PyUnicode_Concat(str, tail);
	6054	Py_DecRef(str);
	6055	Py_DecRef(tail);
	6056	str = joined;
	6057	#else
	6058	PyObject *str = PyString_FromString("(");
	6059	swig_globalvar *var;
	6060	for (var = v->vars; var; var=var->next) {
	6061	PyString_ConcatAndDel(&str,PyString_FromString(var->name));
	6062	if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
	6063	}
	6064	PyString_ConcatAndDel(&str,PyString_FromString(")"));
	6065	#endif
	6066	return str;
	6067	}
	6068
	6069	SWIGINTERN int
	6070	swig_varlink_print(swig_varlinkobject v, FILE fp, int SWIGUNUSEDPARM(flags)) {
	6071	char *tmp;
	6072	PyObject *str = swig_varlink_str(v);
	6073	fprintf(fp,"Swig global variables ");
	6074	fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
	6075	SWIG_Python_str_DelForPy3(tmp);
	6076	Py_DECREF(str);
	6077	return 0;
	6078	}
	6079
	6080	SWIGINTERN void
	6081	swig_varlink_dealloc(swig_varlinkobject *v) {
	6082	swig_globalvar *var = v->vars;
	6083	while (var) {
	6084	swig_globalvar *n = var->next;
	6085	free(var->name);
	6086	free(var);
	6087	var = n;
	6088	}
	6089	}
	6090
	6091	SWIGINTERN PyObject *
	6092	swig_varlink_getattr(swig_varlinkobject v, char n) {
	6093	PyObject *res = NULL;
	6094	swig_globalvar *var = v->vars;
	6095	while (var) {
	6096	if (strcmp(var->name,n) == 0) {
	6097	res = (*var->get_attr)();
	6098	break;
	6099	}
	6100	var = var->next;
	6101	}
	6102	if (res == NULL && !PyErr_Occurred()) {
	6103	PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
	6104	}
	6105	return res;
	6106	}
	6107
	6108	SWIGINTERN int
	6109	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
	6110	int res = 1;
	6111	swig_globalvar *var = v->vars;
	6112	while (var) {
	6113	if (strcmp(var->name,n) == 0) {
	6114	res = (*var->set_attr)(p);
	6115	break;
	6116	}
	6117	var = var->next;
	6118	}
	6119	if (res == 1 && !PyErr_Occurred()) {
	6120	PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
	6121	}
	6122	return res;
	6123	}
	6124
	6125	SWIGINTERN PyTypeObject*
	6126	swig_varlink_type(void) {
	6127	static char varlink__doc__[] = "Swig var link object";
	6128	static PyTypeObject varlink_type;
	6129	static int type_init = 0;
	6130	if (!type_init) {
	6131	const PyTypeObject tmp = {
	6132	/* PyObject header changed in Python 3 */
	6133	#if PY_VERSION_HEX >= 0x03000000
	6134	PyVarObject_HEAD_INIT(NULL, 0)
	6135	#else
	6136	PyObject_HEAD_INIT(NULL)
	6137	0, /* ob_size */
	6138	#endif
	6139	(char )"swigvarlink", / tp_name */
	6140	sizeof(swig_varlinkobject), /* tp_basicsize */
	6141	0, /* tp_itemsize */
	6142	(destructor) swig_varlink_dealloc, /* tp_dealloc */
	6143	(printfunc) swig_varlink_print, /* tp_print */
	6144	(getattrfunc) swig_varlink_getattr, /* tp_getattr */
	6145	(setattrfunc) swig_varlink_setattr, /* tp_setattr */
	6146	0, /* tp_compare */
	6147	(reprfunc) swig_varlink_repr, /* tp_repr */
	6148	0, /* tp_as_number */
	6149	0, /* tp_as_sequence */
	6150	0, /* tp_as_mapping */
	6151	0, /* tp_hash */
	6152	0, /* tp_call */
	6153	(reprfunc) swig_varlink_str, /* tp_str */
	6154	0, /* tp_getattro */
	6155	0, /* tp_setattro */
	6156	0, /* tp_as_buffer */
	6157	0, /* tp_flags */
	6158	varlink__doc__, /* tp_doc */
	6159	0, /* tp_traverse */
	6160	0, /* tp_clear */
	6161	0, /* tp_richcompare */
	6162	0, /* tp_weaklistoffset */
	6163	#if PY_VERSION_HEX >= 0x02020000
	6164	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
	6165	#endif
	6166	#if PY_VERSION_HEX >= 0x02030000
	6167	0, /* tp_del */
	6168	#endif
	6169	#if PY_VERSION_HEX >= 0x02060000
	6170	0, /* tp_version */
	6171	#endif
	6172	#ifdef COUNT_ALLOCS
	6173	0,0,0,0 /* tp_alloc -> tp_next */
	6174	#endif
	6175	};
	6176	varlink_type = tmp;
	6177	type_init = 1;
	6178	#if PY_VERSION_HEX < 0x02020000
	6179	varlink_type.ob_type = &PyType_Type;
	6180	#else
	6181	if (PyType_Ready(&varlink_type) < 0)
	6182	return NULL;
	6183	#endif
	6184	}
	6185	return &varlink_type;
	6186	}
	6187
	6188	/* Create a variable linking object for use later */
	6189	SWIGINTERN PyObject *
	6190	SWIG_Python_newvarlink(void) {
	6191	swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
	6192	if (result) {
	6193	result->vars = 0;
	6194	}
	6195	return ((PyObject*) result);
	6196	}
	6197
	6198	SWIGINTERN void
	6199	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
	6200	swig_varlinkobject v = (swig_varlinkobject ) p;
	6201	swig_globalvar gv = (swig_globalvar ) malloc(sizeof(swig_globalvar));
	6202	if (gv) {
	6203	size_t size = strlen(name)+1;
	6204	gv->name = (char *)malloc(size);
	6205	if (gv->name) {
	6206	strncpy(gv->name,name,size);
	6207	gv->get_attr = get_attr;
	6208	gv->set_attr = set_attr;
	6209	gv->next = v->vars;
	6210	}
	6211	}
	6212	v->vars = gv;
	6213	}
	6214
	6215	SWIGINTERN PyObject *
	6216	SWIG_globals(void) {
	6217	static PyObject *_SWIG_globals = 0;
	6218	if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
	6219	return _SWIG_globals;
	6220	}
	6221
	6222	/* -----------------------------------------------------------------------------
	6223	* constants/methods manipulation
	6224	* ----------------------------------------------------------------------------- */
	6225
	6226	/* Install Constants */
	6227	SWIGINTERN void
	6228	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
	6229	PyObject *obj = 0;
	6230	size_t i;
	6231	for (i = 0; constants[i].type; ++i) {
	6232	switch(constants[i].type) {
	6233	case SWIG_PY_POINTER:
	6234	obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
	6235	break;
	6236	case SWIG_PY_BINARY:
	6237	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
	6238	break;
	6239	default:
	6240	obj = 0;
	6241	break;
	6242	}
	6243	if (obj) {
	6244	PyDict_SetItemString(d, constants[i].name, obj);
	6245	Py_DECREF(obj);
	6246	}
	6247	}
	6248	}
	6249
	6250	/* -----------------------------------------------------------------------------*/
	6251	/* Fix SwigMethods to carry the callback ptrs when needed */
	6252	/* -----------------------------------------------------------------------------*/
	6253
	6254	SWIGINTERN void
	6255	SWIG_Python_FixMethods(PyMethodDef *methods,
	6256	swig_const_info *const_table,
	6257	swig_type_info **types,
	6258	swig_type_info **types_initial) {
	6259	size_t i;
	6260	for (i = 0; methods[i].ml_name; ++i) {
	6261	const char *c = methods[i].ml_doc;
	6262	if (c && (c = strstr(c, "swig_ptr: "))) {
	6263	int j;
	6264	swig_const_info *ci = 0;
	6265	const char *name = c + 10;
	6266	for (j = 0; const_table[j].type; ++j) {
	6267	if (strncmp(const_table[j].name, name,
	6268	strlen(const_table[j].name)) == 0) {
	6269	ci = &(const_table[j]);
	6270	break;
	6271	}
	6272	}
	6273	if (ci) {
	6274	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
	6275	if (ptr) {
	6276	size_t shift = (ci->ptype) - types;
	6277	swig_type_info *ty = types_initial[shift];
	6278	size_t ldoc = (c - methods[i].ml_doc);
	6279	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
	6280	char ndoc = (char)malloc(ldoc + lptr + 10);
	6281	if (ndoc) {
	6282	char *buff = ndoc;
	6283	strncpy(buff, methods[i].ml_doc, ldoc);
	6284	buff += ldoc;
	6285	strncpy(buff, "swig_ptr: ", 10);
	6286	buff += 10;
	6287	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
	6288	methods[i].ml_doc = ndoc;
	6289	}
	6290	}
	6291	}
	6292	}
	6293	}
	6294	}
	6295
	6296	#ifdef __cplusplus
	6297	}
	6298	#endif
	6299
	6300	/* -----------------------------------------------------------------------------*
	6301	* Partial Init method
	6302	* -----------------------------------------------------------------------------*/
	6303
	6304	#ifdef __cplusplus
	6305	extern "C"
	6306	#endif
	6307
	6308	SWIGEXPORT
	6309	#if PY_VERSION_HEX >= 0x03000000
	6310	PyObject*
	6311	#else
	6312	void
	6313	#endif
	6314	SWIG_init(void) {
	6315	PyObject m, d, *md;
	6316	#if PY_VERSION_HEX >= 0x03000000
	6317	static struct PyModuleDef SWIG_module = {
	6318	# if PY_VERSION_HEX >= 0x03020000
	6319	PyModuleDef_HEAD_INIT,
	6320	# else
	6321	{
	6322	PyObject_HEAD_INIT(NULL)
	6323	NULL, /* m_init */
	6324	0, /* m_index */
	6325	NULL, /* m_copy */
	6326	},
	6327	# endif
	6328	(char *) SWIG_name,
	6329	NULL,
	6330	-1,
	6331	SwigMethods,
	6332	NULL,
	6333	NULL,
	6334	NULL,
	6335	NULL
	6336	};
	6337	#endif
	6338
	6339	#if defined(SWIGPYTHON_BUILTIN)
	6340	static SwigPyClientData SwigPyObject_clientdata = {
	6341	0, 0, 0, 0, 0, 0, 0
	6342	};
	6343	static PyGetSetDef this_getset_def = {
	6344	(char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
	6345	};
	6346	static SwigPyGetSet thisown_getset_closure = {
	6347	(PyCFunction) SwigPyObject_own,
	6348	(PyCFunction) SwigPyObject_own
	6349	};
	6350	static PyGetSetDef thisown_getset_def = {
	6351	(char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
	6352	};
	6353	PyObject *metatype_args;
	6354	PyTypeObject *builtin_pytype;
	6355	int builtin_base_count;
	6356	swig_type_info *builtin_basetype;
	6357	PyObject *tuple;
	6358	PyGetSetDescrObject *static_getset;
	6359	PyTypeObject *metatype;
	6360	SwigPyClientData *cd;
	6361	PyObject public_interface, public_symbol;
	6362	PyObject *this_descr;
	6363	PyObject *thisown_descr;
	6364	PyObject *self = 0;
	6365	int i;
	6366
	6367	(void)builtin_pytype;
	6368	(void)builtin_base_count;
	6369	(void)builtin_basetype;
	6370	(void)tuple;
	6371	(void)static_getset;
	6372	(void)self;
	6373
	6374	/* metatype is used to implement static member variables. */
	6375	metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
	6376	assert(metatype_args);
	6377	metatype = (PyTypeObject ) PyType_Type.tp_call((PyObject ) &PyType_Type, metatype_args, NULL);
	6378	assert(metatype);
	6379	Py_DECREF(metatype_args);
	6380	metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
	6381	assert(PyType_Ready(metatype) >= 0);
	6382	#endif
	6383
	6384	/* Fix SwigMethods to carry the callback ptrs when needed */
	6385	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
	6386
	6387	#if PY_VERSION_HEX >= 0x03000000
	6388	m = PyModule_Create(&SWIG_module);
	6389	#else
	6390	m = Py_InitModule((char *) SWIG_name, SwigMethods);
	6391	#endif
	6392
	6393	md = d = PyModule_GetDict(m);
	6394	(void)md;
	6395
	6396	SWIG_InitializeModule(0);
	6397
	6398	#ifdef SWIGPYTHON_BUILTIN
	6399	SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
	6400	assert(SwigPyObject_stype);
	6401	cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
	6402	if (!cd) {
	6403	SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
	6404	SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
	6405	} else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
	6406	PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
	6407	# if PY_VERSION_HEX >= 0x03000000
	6408	return NULL;
	6409	# else
	6410	return;
	6411	# endif
	6412	}
	6413
	6414	/* All objects have a 'this' attribute */
	6415	this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
	6416	(void)this_descr;
	6417
	6418	/* All objects have a 'thisown' attribute */
	6419	thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
	6420	(void)thisown_descr;
	6421
	6422	public_interface = PyList_New(0);
	6423	public_symbol = 0;
	6424	(void)public_symbol;
	6425
	6426	PyDict_SetItemString(md, "__all__", public_interface);
	6427	Py_DECREF(public_interface);
	6428	for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
	6429	SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
	6430	for (i = 0; swig_const_table[i].name != 0; ++i)
	6431	SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
	6432	#endif
	6433
	6434	SWIG_InstallConstants(d,swig_const_table);
	6435
	6436
	6437	import_array(); // required by NumPy
	6438
	6439	#if PY_VERSION_HEX >= 0x03000000
	6440	return m;
	6441	#else
	6442	return;
	6443	#endif
	6444	}
	6445

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: CIVL/examples/omp/shtns/shtns_numpy_wrap.c

Download in other formats: