SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {  swig_type_info *lastty = ty;  if (!ty || !ty->dcast) return ty;  while (ty && (ty->dcast)) {    ty = (*ty->dcast)(ptr);    if (ty) lastty = ty;  }  return lastty;}/*  Return the name associated with this type*/SWIGRUNTIMEINLINE const char *SWIG_TypeName(const swig_type_info *ty) {  return ty->name;}/*  Return the pretty name associated with this type,  that is an unmangled type name in a form presentable to the user.*/SWIGRUNTIME const char *SWIG_TypePrettyName(const swig_type_info *type) {  /* The "str" field contains the equivalent pretty names of the     type, separated by vertical-bar characters.  We choose     to print the last name, as it is often (?) the most     specific. */  if (!type) return NULL;  if (type->str != NULL) {    const char *last_name = type->str;    const char *s;    for (s = type->str; *s; s++)      if (*s == '|') last_name = s+1;    return last_name;  }  else    return type->name;}/*    Set the clientdata field for a type*/SWIGRUNTIME voidSWIG_TypeClientData(swig_type_info *ti, void *clientdata) {  swig_cast_info *cast = ti->cast;  /* if (ti->clientdata == clientdata) return; */  ti->clientdata = clientdata;    while (cast) {    if (!cast->converter) {      swig_type_info *tc = cast->type;      if (!tc->clientdata) {	SWIG_TypeClientData(tc, clientdata);      }    }        cast = cast->next;  }}SWIGRUNTIME voidSWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {  SWIG_TypeClientData(ti, clientdata);  ti->owndata = 1;}  /*  Search for a swig_type_info structure only by mangled name  Search is a O(log #types)    We start searching at module start, and finish searching when start == end.    Note: if start == end at the beginning of the function, we go all the way around  the circular list.*/SWIGRUNTIME swig_type_info *SWIG_MangledTypeQueryModule(swig_module_info *start,                             swig_module_info *end, 		            const char *name) {  swig_module_info *iter = start;  do {    if (iter->size) {      register size_t l = 0;      register size_t r = iter->size - 1;      do {	/* since l+r >= 0, we can (>> 1) instead (/ 2) */	register size_t i = (l + r) >> 1; 	const char *iname = iter->types[i]->name;	if (iname) {	  register int compare = strcmp(name, iname);	  if (compare == 0) {	    	    return iter->types[i];	  } else if (compare < 0) {	    if (i) {	      r = i - 1;	    } else {	      break;	    }	  } else if (compare > 0) {	    l = i + 1;	  }	} else {	  break; /* should never happen */	}      } while (l <= r);    }    iter = iter->next;  } while (iter != end);  return 0;}/*  Search for a swig_type_info structure for either a mangled name or a human readable name.  It first searches the mangled names of the types, which is a O(log #types)  If a type is not found it then searches the human readable names, which is O(#types).    We start searching at module start, and finish searching when start == end.    Note: if start == end at the beginning of the function, we go all the way around  the circular list.*/SWIGRUNTIME swig_type_info *SWIG_TypeQueryModule(swig_module_info *start,                      swig_module_info *end, 		     const char *name) {  /* STEP 1: Search the name field using binary search */  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);  if (ret) {    return ret;  } else {    /* STEP 2: If the type hasn't been found, do a complete search       of the str field (the human readable name) */    swig_module_info *iter = start;    do {      register size_t i = 0;      for (; i < iter->size; ++i) {	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))	  return iter->types[i];      }      iter = iter->next;    } while (iter != end);  }    /* neither found a match */  return 0;}/*    Pack binary data into a string*/SWIGRUNTIME char *SWIG_PackData(char *c, void *ptr, size_t sz) {  static const char hex[17] = "0123456789abcdef";  register const unsigned char *u = (unsigned char *) ptr;  register const unsigned char *eu =  u + sz;  for (; u != eu; ++u) {    register unsigned char uu = *u;    *(c++) = hex[(uu & 0xf0) >> 4];    *(c++) = hex[uu & 0xf];  }  return c;}/*    Unpack binary data from a string*/SWIGRUNTIME const char *SWIG_UnpackData(const char *c, void *ptr, size_t sz) {  register unsigned char *u = (unsigned char *) ptr;  register const unsigned char *eu = u + sz;  for (; u != eu; ++u) {    register char d = *(c++);    register unsigned char uu;    if ((d >= '0') && (d <= '9'))      uu = ((d - '0') << 4);    else if ((d >= 'a') && (d <= 'f'))      uu = ((d - ('a'-10)) << 4);    else       return (char *) 0;    d = *(c++);    if ((d >= '0') && (d <= '9'))      uu |= (d - '0');    else if ((d >= 'a') && (d <= 'f'))      uu |= (d - ('a'-10));    else       return (char *) 0;    *u = uu;  }  return c;}/*    Pack 'void *' into a string buffer.*/SWIGRUNTIME char *SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {  char *r = buff;  if ((2*sizeof(void *) + 2) > bsz) return 0;  *(r++) = '_';  r = SWIG_PackData(r,&ptr,sizeof(void *));  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;  strcpy(r,name);  return buff;}SWIGRUNTIME const char *SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {  if (*c != '_') {    if (strcmp(c,"NULL") == 0) {      *ptr = (void *) 0;      return name;    } else {      return 0;    }  }  return SWIG_UnpackData(++c,ptr,sizeof(void *));}SWIGRUNTIME char *SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {  char *r = buff;  size_t lname = (name ? strlen(name) : 0);  if ((2*sz + 2 + lname) > bsz) return 0;  *(r++) = '_';  r = SWIG_PackData(r,ptr,sz);  if (lname) {    strncpy(r,name,lname+1);  } else {    *r = 0;  }  return buff;}SWIGRUNTIME const char *SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {  if (*c != '_') {    if (strcmp(c,"NULL") == 0) {      memset(ptr,0,sz);      return name;    } else {      return 0;    }  }  return SWIG_UnpackData(++c,ptr,sz);}#ifdef __cplusplus}#endif/*  Errors in SWIG */#define  SWIG_UnknownError    	   -1 #define  SWIG_IOError        	   -2 #define  SWIG_RuntimeError   	   -3 #define  SWIG_IndexError     	   -4 #define  SWIG_TypeError      	   -5 #define  SWIG_DivisionByZero 	   -6 #define  SWIG_OverflowError  	   -7 #define  SWIG_SyntaxError    	   -8 #define  SWIG_ValueError     	   -9 #define  SWIG_SystemError    	   -10#define  SWIG_AttributeError 	   -11#define  SWIG_MemoryError    	   -12 #define  SWIG_NullReferenceError   -13/* ----------------------------------------------------------------------------- * error manipulation * ----------------------------------------------------------------------------- */SWIGINTERN const char*SWIG_Tcl_ErrorType(int code) {  const char* type = 0;  switch(code) {  case SWIG_MemoryError:    type = "MemoryError";    break;  case SWIG_IOError:    type = "IOError";    break;  case SWIG_RuntimeError:    type = "RuntimeError";    break;  case SWIG_IndexError:    type = "IndexError";    break;  case SWIG_TypeError:    type = "TypeError";    break;  case SWIG_DivisionByZero:    type = "ZeroDivisionError";    break;  case SWIG_OverflowError:    type = "OverflowError";    break;  case SWIG_SyntaxError:    type = "SyntaxError";    break;  case SWIG_ValueError:    type = "ValueError";    break;  case SWIG_SystemError:    type = "SystemError";    break;  case SWIG_AttributeError:    type = "AttributeError";    break;  default:    type = "RuntimeError";  }  return type;}SWIGINTERN voidSWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj){  Tcl_ResetResult(interp);  Tcl_SetObjResult(interp, obj);  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);}SWIGINTERN voidSWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg){  Tcl_ResetResult(interp);  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);  Tcl_AppendResult(interp, ctype, " ", mesg, NULL);  /*  Tcl_AddErrorInfo(interp, ctype);  Tcl_AddErrorInfo(interp, " ");  Tcl_AddErrorInfo(interp, mesg);  */}SWIGINTERNINLINE voidSWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg){  Tcl_AddErrorInfo(interp, mesg);}/* ----------------------------------------------------------------------------- * SWIG API. Portion that goes into the runtime * ----------------------------------------------------------------------------- */#ifdef __cplusplusextern "C" {#endif/* ----------------------------------------------------------------------------- * Constant declarations * ----------------------------------------------------------------------------- *//* Constant Types */#define SWIG_TCL_POINTER 4#define SWIG_TCL_BINARY  5/* Constant information structure */typedef struct swig_const_info {    int type;    char *name;    long lvalue;    double dvalue;    void   *pvalue;    swig_type_info **ptype;} swig_const_info;typedef int   (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);typedef int   (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);typedef void  (*swig_delete_func)(ClientData);typedef struct swig_method {  const char     *name;  swig_wrapper   method;} swig_method;typedef struct swig_attribute {  const char     *name;  swig_wrapper   getmethod;  swig_wrapper   setmethod;} swig_attribute;typedef struct swig_class {  const char         *name;  swig_type_info   **type;  swig_wrapper       constructor;  void              (*destructor)(void *);  swig_method        *methods;  swig_attribute     *attributes;  struct swig_class **bases;  char              **base_names;  swig_module_info   *module;} swig_class;typedef struct swig_instance {  Tcl_Obj       *thisptr;  void          *thisvalue;  swig_class   *classptr;  int            destroy;  Tcl_Command    cmdtok;} swig_instance;/* Structure for command table */typedef struct {  const char *name;  int       (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);  ClientData  clientdata;} swig_command_info;/* Structure for variable linking table */typedef struct {  const char *name;  void *addr;  char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);  char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);} swig_var_info;/* -----------------------------------------------------------------------------* *  Install a constant object  * -----------------------------------------------------------------------------*/static Tcl_HashTable   swigconstTable;static int             swigconstTableinit = 0;SWIGINTERN voidSWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {  int newobj;  Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);  Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);}SWIGINTERN Tcl_Obj *SWIG_Tcl_GetConstantObj(const char *key) {  Tcl_HashEntry *entryPtr;  if (!swigconstTableinit) return 0;  entryPtr = Tcl_FindHashEntry(&swigconstTable, key);